9router 0.3.50 → 0.3.52

package/app/src/mitm/server2.js

@@ -75,6 +75,14 @@ const CURSOR_ENDPOINTS = [
   "/agent.v1.AgentService/RunSSE",
 ];
 
+// Mock rules: if last user message contains key → reply with value
+const MOCK_RULES = {
+  "aaa": "bbb",
+};
+
+// conversationId → mock reply (set when AgentRunRequest matches a rule)
+const mockPending = new Map();
+
 /**
  * Decode Connect-RPC frame: [1 byte flags][4 bytes length][protobuf body]
  * Then walk raw protobuf fields and extract readable strings/numbers.
@@ -561,75 +569,57 @@ function decodeConversationState(buf) {
 }
 
 // ── Save per-chat JSON file ────────────────────────────────────
+// Only logs AgentRunRequest and ExecClientMessage — skips noise (RunPoll, KvClientMessage, ClientHeartbeat...)
 function saveCursorLogFull(url, headers, buf) {
   try {
     if (buf.length < 5) return;
+    if (!url.includes("BidiAppend")) return;
 
-    const isBidiAppend = url.includes("BidiAppend");
-    const isRunPoll = url.includes("RunPoll");
-    if (!isBidiAppend && !isRunPoll) return;
-
-    // Decompress if gzip, otherwise use raw
-    let raw;
     const isGzip = buf[0] === 0x1f && buf[1] === 0x8b;
-    if (isGzip) {
-      raw = zlib.gunzipSync(buf);
-    } else {
-      // Try strip Connect-RPC envelope if present (flag byte + 4-byte length)
-      raw = (buf[0] === 0x00 || buf[0] === 0x01) ? buf.slice(5) : buf;
-    }
+    const raw = isGzip ? zlib.gunzipSync(buf) : (buf[0] === 0x00 || buf[0] === 0x01 ? buf.slice(5) : buf);
 
-    const endpoint = isBidiAppend ? "BidiAppend" : "RunPoll";
-    let decoded = {};
-    let userMessage = null;
+    const decoded = decodeBidiAppend(raw);
+    const msgType = decoded?.agentMsg?.type;
 
-    if (isBidiAppend) {
-      decoded = decodeBidiAppend(raw);
-      const action = decoded?.agentMsg?.action || {};
-      userMessage = action.textFull || action.text || null;
-    } else {
-      // RunPoll: BidiPollRequest — f1=requestId{f1=uuid}, f2=startRequest
-      const fields = protoWalkFields(raw);
-      for (const f of fields) {
-        if (f.field === 1 && f.data) {
-          const inner = protoWalkFields(f.data);
-          const id = inner.find(x => x.field === 1 && x.data);
-          decoded.requestId = id ? protoStr(id.data) : null;
-        }
-        if (f.field === 2) decoded.startRequest = f.value === 1;
-      }
-    }
+    // Only log meaningful message types
+    if (msgType !== "AgentRunRequest" && msgType !== "ExecClientMessage") return;
 
-    // Fetch conversation history from local Cursor DB when AgentRunRequest detected
+    const action = decoded?.agentMsg?.action || {};
+    const userMessage = action.textFull || action.text || null;
+
+    // Fetch full conversation from DB for AgentRunRequest
     const conversationId = decoded?.agentMsg?.conversationId || null;
     let conversation = null;
-    if (conversationId && decoded?.agentMsg?.type === "AgentRunRequest") {
+    if (conversationId && msgType === "AgentRunRequest") {
       conversation = readConversationFromDb(conversationId);
+
+      // Check MOCK_RULES against last user message
+      const lastMsg = userMessage || "";
+      for (const [keyword, reply] of Object.entries(MOCK_RULES)) {
+        if (lastMsg.toLowerCase().includes(keyword.toLowerCase())) {
+          mockPending.set(conversationId, reply);
+          console.log(`[MOCK] Triggered rule "${keyword}" → "${reply}" for conv=${conversationId}`);
+          break;
+        }
+      }
     }
 
     const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const base = path.join(CURSOR_LOG_DIR, `${ts}_${endpoint}`);
-
-    // _chat.json — structured decoded
-    fs.writeFileSync(`${base}_chat.json`, JSON.stringify({
-      ts: new Date().toISOString(),
-      endpoint,
-      version: headers["x-cursor-client-version"] || null,
-      encoding: isGzip ? "gzip" : "raw",
-      sizeIn: buf.length,
-      sizeRaw: raw.length,
-      userMessage,
-      decoded,
-      conversation,
-    }, null, 2));
-
-    // _decoded.json — full proto tree, no filtering
-    const tree = protoTreeToObj(raw);
-    fs.writeFileSync(`${base}_decoded.json`, JSON.stringify(tree, null, 2));
-
-    const agentType = decoded?.agentMsg?.type || decoded?.requestId || "(none)";
+    fs.writeFileSync(
+      path.join(CURSOR_LOG_DIR, `${ts}_${msgType}_chat.json`),
+      JSON.stringify({
+        ts: new Date().toISOString(),
+        type: msgType,
+        version: headers["x-cursor-client-version"] || null,
+        sizeIn: buf.length,
+        userMessage,
+        decoded,
+        conversation,
+      }, null, 2)
+    );
+
     const convName = conversation?.name ? ` | conv="${conversation.name}" (${conversation.totalMessages} msgs)` : "";
-    console.log(`[CURSOR] ${endpoint} | type=${agentType} | msg=${userMessage || "(none)"}${convName} | ${isGzip ? "gzip" : "raw"} ${buf.length}B`);
+    console.log(`[CURSOR] ${msgType} | msg=${userMessage || "(none)"}${convName} | ${buf.length}B`);
   } catch (e) {
     console.error(`[CURSOR] decode error: ${e.message}`);
   }
@@ -761,7 +751,93 @@ function getToolForHost(host) {
   return null;
 }
 
-async function passthrough(req, res, bodyBuffer) {
+/**
+ * Encode a single protobuf length-delimited field: (fieldNum << 3 | wireType) + varint(len) + bytes
+ * wireType 2 = length-delimited, wireType 0 = varint
+ */
+function protoEncodeField(fieldNum, wireType, data) {
+  const tag = (fieldNum << 3) | wireType;
+  const tagBuf = encodeVarint(tag);
+  if (wireType === 2) {
+    const lenBuf = encodeVarint(data.length);
+    return Buffer.concat([tagBuf, lenBuf, data]);
+  }
+  // wireType 0: data is already a varint buffer
+  return Buffer.concat([tagBuf, data]);
+}
+
+function encodeVarint(n) {
+  const bufs = [];
+  while (n > 0x7f) {
+    bufs.push((n & 0x7f) | 0x80);
+    n >>>= 7;
+  }
+  bufs.push(n & 0x7f);
+  return Buffer.from(bufs);
+}
+
+/**
+ * Build a Connect-RPC streaming frame: [flags=0][4-byte big-endian length][body]
+ */
+function buildConnectFrame(body) {
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(body.length, 0);
+  return Buffer.concat([Buffer.from([0x00]), lenBuf, body]);
+}
+
+/**
+ * Build one gzip-compressed Connect-RPC data frame containing a BidiPollResponse.
+ * BidiPollResponse: f1=seqno(varint), f2=data(hex string of AgentServerMessage)
+ * AgentServerMessage.f1 = InteractionUpdate.f1 = TextDeltaUpdate.f1 = text
+ */
+function buildFakePollFrame(text, seqno) {
+  const zlib = require("zlib");
+
+  // TextDeltaUpdate { f1: text }
+  const textDelta = protoEncodeField(1, 2, Buffer.from(text, "utf8"));
+  // InteractionUpdate { f1: TextDeltaUpdate }
+  const interactionUpdate = protoEncodeField(1, 2, textDelta);
+  // AgentServerMessage { f1: InteractionUpdate }
+  const agentMsg = protoEncodeField(1, 2, interactionUpdate);
+
+  // BidiPollResponse { f1: seqno, f2: hex(agentMsg) }
+  let pollResp = protoEncodeField(1, 0, encodeVarint(seqno));
+  pollResp = Buffer.concat([pollResp, protoEncodeField(2, 2, Buffer.from(agentMsg.toString("hex"), "utf8"))]);
+
+  // Gzip compress (flags=1)
+  const compressed = zlib.gzipSync(pollResp);
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(compressed.length, 0);
+  return Buffer.concat([Buffer.from([0x01]), lenBuf, compressed]);
+}
+
+/**
+ * Build Connect-RPC end-of-stream trailer frame: flags=0x02, body={}
+ */
+function buildTrailerFrame() {
+  const body = Buffer.from("{}", "utf8");
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeUInt32BE(body.length, 0);
+  return Buffer.concat([Buffer.from([0x02]), lenBuf, body]);
+}
+
+/**
+ * Send fake RunPoll response matching real Cursor server format
+ */
+function sendMockResponse(res, replyText) {
+  res.writeHead(200, {
+    "content-type": "application/connect+proto",
+    "transfer-encoding": "chunked",
+  });
+
+  // Send text as single frame + trailer
+  res.write(buildFakePollFrame(replyText, 1));
+  res.write(buildTrailerFrame());
+  res.end();
+  console.log(`[MOCK] RunPoll → "${replyText}"`);
+}
+
+async function passthrough(req, res, bodyBuffer, captureFile = null) {
   const targetHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
   const targetIP = await resolveTargetIP(targetHost);
 
@@ -774,8 +850,121 @@ async function passthrough(req, res, bodyBuffer) {
     servername: targetHost,
     rejectUnauthorized: false
   }, (forwardRes) => {
+    // Log headers + first frame raw bytes of first RunPoll response for mock calibration
+    if (req.url.includes("RunPoll") && !passthrough._loggedRunPollHeaders) {
+      passthrough._loggedRunPollHeaders = true;
+      console.log("[DBG] RunPoll headers:", JSON.stringify(forwardRes.headers));
+      const origWrite = res.write.bind(res);
+      let logged = false;
+      res.write = function(chunk) {
+        if (!logged) {
+          logged = true;
+          console.log("[DBG] RunPoll first chunk hex:", Buffer.isBuffer(chunk) ? chunk.slice(0, 80).toString("hex") : Buffer.from(chunk).slice(0, 80).toString("hex"));
+        }
+        return origWrite(chunk);
+      };
+    }
     res.writeHead(forwardRes.statusCode, forwardRes.headers);
-    forwardRes.pipe(res);
+
+    if (!captureFile) {
+      forwardRes.pipe(res);
+      return;
+    }
+
+    // Tee response: forward to client AND decode+save to file
+    const chunks = [];
+    forwardRes.on("data", chunk => {
+      chunks.push(chunk);
+      res.write(chunk);
+    });
+    forwardRes.on("end", () => {
+      res.end();
+      try {
+        const raw = Buffer.concat(chunks);
+        // Save first RunPoll raw that has text (frames > 20)
+        if (req.url.includes("RunPoll") && !passthrough._savedTextRaw && frameCount > 20) {
+          passthrough._savedTextRaw = true;
+          fs.writeFileSync(path.join(CURSOR_LOG_DIR, "_runpoll_text_raw.hex"), raw.toString("hex"));
+          console.log("[DBG] RunPoll TEXT raw saved, len=", raw.length, "frames=", frameCount);
+        }
+        // Decode Connect-RPC streaming frames: each frame = [1B flags][4B len][proto body]
+        const textChunks = [];
+        const toolCalls = [];
+        let frameCount = 0;
+        let offset = 0;
+
+        while (offset + 5 <= raw.length) {
+          const flags = raw[offset];
+          const msgLen = raw.readUInt32BE(offset + 1);
+          if (offset + 5 + msgLen > raw.length) break;
+          let body = raw.slice(offset + 5, offset + 5 + msgLen);
+          offset += 5 + msgLen;
+          frameCount++;
+
+          // Decompress gzip frame (flags=1)
+          if (flags === 1) {
+            try { body = zlib.gunzipSync(body); } catch { continue; }
+          }
+
+          // BidiPollResponse: f1=seqno(varint), f2=data(hex-encoded AgentServerMessage)
+          const pollFields = protoWalkFields(body);
+          const dataField = pollFields.find(f => f.field === 2 && f.data);
+          if (!dataField) continue;
+
+          // f2.data is ASCII hex string → decode to actual AgentServerMessage bytes
+          const hexStr = dataField.data.toString("utf8");
+          if (!/^[0-9a-f]+$/i.test(hexStr)) continue;
+          const agentMsg = Buffer.from(hexStr, "hex");
+
+          // AgentServerMessage: f1=InteractionUpdate, f2=ExecServerMessage
+          const agentFields = protoWalkFields(agentMsg);
+
+          // f1 = InteractionUpdate → f1=TextDeltaUpdate.f1=text
+          const interactionUpdate = agentFields.find(f => f.field === 1 && f.data);
+          if (interactionUpdate) {
+            const iuFields = protoWalkFields(interactionUpdate.data);
+            const textDelta = iuFields.find(f => f.field === 1 && f.data);
+            if (textDelta) {
+              const tdFields = protoWalkFields(textDelta.data);
+              const textField = tdFields.find(f => f.field === 1 && f.data);
+              if (textField) {
+                const text = textField.data.toString("utf8");
+                if (text.length > 0) textChunks.push(text);
+              }
+            }
+          }
+
+          // f2 = ExecServerMessage → decode tool call
+          // ExecServerMessage: f1=id(varint), f15=exec_id(str), f2=shell, f3=write, f4=delete, f5=grep, f7=read, f8=ls
+          const execMsg = agentFields.find(f => f.field === 2 && f.data);
+          if (execMsg) {
+            const execFields = protoWalkFields(execMsg.data);
+            const toolFieldMap = { 2: "shell", 3: "write", 4: "delete", 5: "grep", 7: "read", 8: "ls", 11: "mcp", 14: "shell_stream", 20: "fetch" };
+            const toolField = execFields.find(f => toolFieldMap[f.field] && f.data);
+            if (toolField) {
+              const toolName = toolFieldMap[toolField.field];
+              // Extract first string field as main arg (command/path)
+              const argFields = protoWalkFields(toolField.data);
+              const mainArg = argFields.find(f => f.field === 1 && f.data);
+              const arg = mainArg ? mainArg.data.toString("utf8") : null;
+              toolCalls.push({ tool: toolName, arg });
+            }
+          }
+        }
+
+        const assembled = textChunks.length > 0 ? textChunks.join("") : null;
+        // Only save file if there's actual content
+        if (assembled || toolCalls.length > 0) {
+          const entry = { ts: new Date().toISOString(), frames: frameCount };
+          if (assembled) entry.text = assembled;
+          if (toolCalls.length > 0) entry.tools = toolCalls;
+          fs.writeFileSync(captureFile, JSON.stringify(entry, null, 2));
+          const toolSummary = toolCalls.map(t => `${t.tool}(${(t.arg || "").slice(0, 40)})`).join(", ");
+          const preview = assembled ? `"${assembled.slice(0, 80)}"` : "";
+          console.log(`[CURSOR] RunPoll ← ${preview}${toolSummary ? ` [${toolSummary}]` : ""}`);
+        }
+      } catch { /* ignore */ }
+    });
   });
 
   forwardReq.on("error", (err) => {
@@ -838,11 +1027,31 @@ const server = https.createServer(sslOptions, async (req, res) => {
   const bodyBuffer = await collectBodyRaw(req);
   if (bodyBuffer.length > 0) saveRequestLog(req.url, bodyBuffer);
 
-  // Decode and log Cursor protobuf endpoints
+  // Decode and log Cursor protobuf request endpoints
   if (CURSOR_ENDPOINTS.some(e => req.url.includes(e))) {
     saveCursorLogFull(req.url, req.headers, bodyBuffer);
   }
 
+  // Capture response of RunPoll (server streams BidiPollResponse chunks back)
+  const isRunPoll = req.url.includes("RunPoll");
+  if (isRunPoll) {
+    // Check if there's a mock rule pending for this conversation
+    // Extract conversationId from BidiPollRequest.f1 (BidiRequestId) → need to check mockPending
+    // Simple approach: check all pending mocks and reply for any RunPoll within same session
+    // Since mockPending is keyed by conversationId and RunPoll doesn't carry it directly,
+    // we intercept the first RunPoll after a matching AgentRunRequest by checking pendingQueue
+    if (mockPending.size > 0) {
+      // Pick the first pending mock (FIFO) — matches the most recent matching conversation
+      const [convId, replyText] = mockPending.entries().next().value;
+      mockPending.delete(convId);
+      return sendMockResponse(res, replyText);
+    }
+
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const captureFile = path.join(CURSOR_LOG_DIR, `${ts}_RunPoll_response.json`);
+    return passthrough(req, res, bodyBuffer, captureFile);
+  }
+
   // Anti-loop: requests originating from 9Router bypass interception
   if (req.headers[INTERNAL_REQUEST_HEADER.name] === INTERNAL_REQUEST_HEADER.value) {
     return passthrough(req, res, bodyBuffer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "9router",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "description": "9Router CLI - Start and manage 9Router server",
   "bin": {
     "9router": "./cli.js"