9router 0.3.48 → 0.3.50

package/app/node_modules/file-uri-to-path/index.js

@@ -0,0 +1,66 @@
+
+/**
+ * Module dependencies.
+ */
+
+var sep = require('path').sep || '/';
+
+/**
+ * Module exports.
+ */
+
+module.exports = fileUriToPath;
+
+/**
+ * File URI to Path function.
+ *
+ * @param {String} uri
+ * @return {String} path
+ * @api public
+ */
+
+function fileUriToPath (uri) {
+  if ('string' != typeof uri ||
+      uri.length <= 7 ||
+      'file://' != uri.substring(0, 7)) {
+    throw new TypeError('must pass in a file:// URI to convert to a file path');
+  }
+
+  var rest = decodeURI(uri.substring(7));
+  var firstSlash = rest.indexOf('/');
+  var host = rest.substring(0, firstSlash);
+  var path = rest.substring(firstSlash + 1);
+
+  // 2.  Scheme Definition
+  // As a special case, <host> can be the string "localhost" or the empty
+  // string; this is interpreted as "the machine from which the URL is
+  // being interpreted".
+  if ('localhost' == host) host = '';
+
+  if (host) {
+    host = sep + sep + host;
+  }
+
+  // 3.2  Drives, drive letters, mount points, file system root
+  // Drive letters are mapped into the top of a file URI in various ways,
+  // depending on the implementation; some applications substitute
+  // vertical bar ("|") for the colon after the drive letter, yielding
+  // "file:///c|/tmp/test.txt".  In some cases, the colon is left
+  // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
+  // colon is simply omitted, as in "file:///c/tmp/test.txt".
+  path = path.replace(/^(.+)\|/, '$1:');
+
+  // for Windows, we need to invert the path separators from what a URI uses
+  if (sep == '\\') {
+    path = path.replace(/\//g, '\\');
+  }
+
+  if (/^.+\:/.test(path)) {
+    // has Windows drive at beginning of path
+  } else {
+    // unix path…
+    path = sep + path;
+  }
+
+  return host + path;
+}

package/app/node_modules/file-uri-to-path/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "file-uri-to-path",
+  "version": "1.0.0",
+  "description": "Convert a file: URI to a file path",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "mocha --reporter spec"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/TooTallNate/file-uri-to-path.git"
+  },
+  "keywords": [
+    "file",
+    "uri",
+    "convert",
+    "path"
+  ],
+  "author": "Nathan Rajlich <nathan@tootallnate.net> (http://n8.io/)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/TooTallNate/file-uri-to-path/issues"
+  },
+  "homepage": "https://github.com/TooTallNate/file-uri-to-path",
+  "devDependencies": {
+    "mocha": "3"
+  }
+}

package/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "9router-app",
-  "version": "0.3.48",
+  "version": "0.3.50",
   "description": "9Router web dashboard",
   "private": true,
   "scripts": {
@@ -15,6 +15,7 @@
     "@monaco-editor/react": "^4.7.0",
     "@xyflow/react": "^12.10.1",
     "bcryptjs": "^3.0.3",
+    "better-sqlite3": "^12.6.2",
     "confbox": "^0.2.4",
     "express": "^5.2.1",
     "fs": "^0.0.1-security",

package/app/src/mitm/manager.js

@@ -16,6 +16,14 @@ const MITM_PORT = 443;
 const MITM_WIN_NODE_PORT = 8443;
 const PID_FILE = path.join(MITM_DIR, ".mitm.pid");
 
+const MITM_MAX_RESTARTS = 5;
+const MITM_RESTART_DELAYS_MS = [5000, 10000, 20000, 30000, 60000];
+const MITM_RESTART_RESET_MS = 60000;
+
+let mitmRestartCount = 0;
+let mitmLastStartTime = 0;
+let mitmIsRestarting = false;
+
 function resolveServerPath() {
   if (process.env.MITM_SERVER_PATH) return process.env.MITM_SERVER_PATH;
   const sibling = path.join(__dirname, "server.js");
@@ -273,6 +281,50 @@ async function getMitmStatus() {
   return { running, pid, certExists, dnsStatus };
 }
 
+async function scheduleMitmRestart(apiKey) {
+  if (mitmIsRestarting) return;
+
+  const aliveMs = Date.now() - mitmLastStartTime;
+  if (aliveMs >= MITM_RESTART_RESET_MS) mitmRestartCount = 0;
+
+  if (mitmRestartCount >= MITM_MAX_RESTARTS) {
+    console.error("[MITM] Max restart attempts reached. Giving up.");
+    return;
+  }
+
+  const attempt = mitmRestartCount;
+  const delay = MITM_RESTART_DELAYS_MS[Math.min(attempt, MITM_RESTART_DELAYS_MS.length - 1)];
+  mitmRestartCount++;
+  mitmIsRestarting = true;
+
+  console.log(`[MITM] Restarting in ${delay / 1000}s... (${mitmRestartCount}/${MITM_MAX_RESTARTS})`);
+  await new Promise((r) => setTimeout(r, delay));
+
+  try {
+    const settings = _getSettings ? await _getSettings() : null;
+    if (settings && !settings.mitmEnabled) {
+      console.log("[MITM] MITM disabled, skipping restart");
+      mitmIsRestarting = false;
+      return;
+    }
+    const password = getCachedPassword() || await loadEncryptedPassword();
+    if (!password && !IS_WIN) {
+      console.error("[MITM] No cached password, cannot auto-restart");
+      mitmIsRestarting = false;
+      return;
+    }
+    await startServer(apiKey, password);
+    console.log("[MITM] Restarted successfully");
+    mitmRestartCount = 0;
+    mitmIsRestarting = false;
+  } catch (err) {
+    console.error(`[MITM] Restart attempt ${mitmRestartCount}/${MITM_MAX_RESTARTS} failed:`, err.message);
+    mitmIsRestarting = false;
+    // Schedule next retry
+    scheduleMitmRestart(apiKey);
+  }
+}
+
 /**
  * Start MITM server only (cert + server, no DNS)
  */
@@ -378,6 +430,7 @@ async function startServer(apiKey, sudoPassword) {
   if (!IS_WIN && serverProcess) {
     serverPid = serverProcess.pid;
     fs.writeFileSync(PID_FILE, String(serverPid));
+    mitmLastStartTime = Date.now();
   }
 
   let startError = null;
@@ -397,6 +450,8 @@ async function startServer(apiKey, sudoPassword) {
       serverProcess = null;
       serverPid = null;
       try { fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
+      // Auto-restart on unexpected exit
+      if (code !== 0 && !mitmIsRestarting) scheduleMitmRestart(apiKey);
     });
   }
 
@@ -425,6 +480,9 @@ async function startServer(apiKey, sudoPassword) {
  * Stop MITM server — removes ALL tool DNS entries first, then kills server
  */
 async function stopServer(sudoPassword) {
+  // Prevent auto-restart from triggering on intentional stop
+  mitmIsRestarting = true;
+  mitmRestartCount = 0;
   console.log("[MITM] Stopping server...");
 
   // Kill server process
@@ -476,6 +534,7 @@ async function stopServer(sudoPassword) {
 
   try { fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
   await saveMitmSettings(false, null);
+  mitmIsRestarting = false;
 
   return { running: false, pid: null };
 }

package/app/src/mitm/server.js

@@ -85,7 +85,7 @@ const ANTIGRAVITY_URL_PATTERNS = [":generateContent", ":streamGenerateContent"];
 // Copilot: OpenAI-compatible + Anthropic endpoints
 const COPILOT_URL_PATTERNS = ["/chat/completions", "/v1/messages", "/responses"];
 
-const LOG_DIR = path.join(__dirname, "../../logs/mitm");
+const LOG_DIR = path.join(DATA_DIR, "logs", "mitm");
 if (ENABLE_FILE_LOG && !fs.existsSync(LOG_DIR)) fs.mkdirSync(LOG_DIR, { recursive: true });
 
 function saveRequestLog(url, bodyBuffer) {

package/app/src/mitm/{server copy.js → server2.js}

@@ -3,6 +3,50 @@ const fs = require("fs");
 const path = require("path");
 const dns = require("dns");
 const { promisify } = require("util");
+const Database = require("better-sqlite3");
+
+const CURSOR_GLOBAL_DB = path.join(
+  process.env.HOME,
+  "Library/Application Support/Cursor/User/globalStorage/state.vscdb"
+);
+
+// Read full conversation from Cursor global DB
+function readConversationFromDb(conversationId) {
+  try {
+    const db = new Database(CURSOR_GLOBAL_DB, { readonly: true, fileMustExist: true });
+    const stmt = db.prepare("SELECT value FROM cursorDiskKV WHERE key=?");
+
+    const row = stmt.get(`composerData:${conversationId}`);
+    if (!row) { db.close(); return null; }
+
+    const composer = JSON.parse(row.value);
+    const headers = composer.fullConversationHeadersOnly || [];
+    const name = composer.name || "";
+
+    const messages = [];
+    for (const h of headers) {
+      const brow = stmt.get(`bubbleId:${conversationId}:${h.bubbleId}`);
+      if (!brow) continue;
+      const bubble = JSON.parse(brow.value);
+      const role = h.type === 1 ? "user" : "assistant";
+      const text = (bubble.text || "").trim();
+      const ts = bubble.createdAt || null;
+
+      // Tool call bubble (no text but has toolFormerData)
+      const tool = bubble.toolFormerData && bubble.toolFormerData.name
+        ? { name: bubble.toolFormerData.name, args: bubble.toolFormerData.rawArgs || null, status: bubble.toolFormerData.status || null }
+        : null;
+
+      if (!text && !tool) continue;
+      messages.push({ role, text: text || null, tool, ts });
+    }
+
+    db.close();
+    return { name, totalMessages: headers.length, messages };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
 
 const INTERNAL_REQUEST_HEADER = { name: "x-request-source", value: "local" };
 
@@ -27,6 +71,8 @@ const CURSOR_JSONL = path.join(CURSOR_LOG_DIR, "cursor_messages.jsonl");
 const CURSOR_ENDPOINTS = [
   "/agent.v1.AgentService/RunPoll",
   "/aiserver.v1.BidiService/BidiAppend",
+  "/agent.v1.AgentService/Run",
+  "/agent.v1.AgentService/RunSSE",
 ];
 
 /**
@@ -265,29 +311,67 @@ function decodeBidiAppend(buf) {
   return result;
 }
 
-// AgentClientMessage oneof: f1=AgentRunRequest, f4=ConversationAction, f7=ClientHeartbeat
+// AgentClientMessage oneof: f1=AgentRunRequest, f2=ExecClientMessage, f3=KvClientMessage, f4=ConversationAction, f5=ExecClientControlMessage, f6=InteractionResponse, f7=ClientHeartbeat
 function decodeAgentClientMsg(buf) {
   const fields = protoWalkFields(buf);
   for (const f of fields) {
-    if (!f.data) continue;
-    if (f.field === 1) return { type: "AgentRunRequest", ...decodeAgentRunRequest(f.data) };
-    if (f.field === 4) return { type: "ConversationAction", ...decodeConversationAction(f.data) };
+    // f7=ClientHeartbeat: wire-type 2 but empty (len=0), data is Buffer(0)
     if (f.field === 7) return { type: "ClientHeartbeat" };
-    if (f.field === 2) return { type: "ExecClientMessage" };
+    if (f.data === undefined || f.data === null) continue;
+    if (f.field === 1 && f.data.length > 0) return { type: "AgentRunRequest", ...decodeAgentRunRequest(f.data) };
+    if (f.field === 2 && f.data.length > 0) return { type: "ExecClientMessage", ...decodeExecClientMessage(f.data) };
+    if (f.field === 3) return { type: "KvClientMessage" };
+    if (f.field === 4 && f.data.length > 0) return { type: "ConversationAction", ...decodeConversationAction(f.data) };
+    if (f.field === 5) return { type: "ExecClientControlMessage" };
+    if (f.field === 6) return { type: "InteractionResponse" };
   }
   return { type: "unknown" };
 }
 
-// AgentRunRequest: f1=conversation_state, f2=action, f3=model_details, f5=conversation_id
+// AgentRunRequest: f1=conversation_state, f2=action, f3=model_details, f4=mcp_tools, f5=conversation_id, f6=mcp_file_system_options, f7=skill_options
 function decodeAgentRunRequest(buf) {
   const fields = protoWalkFields(buf);
   const result = {};
 
   for (const f of fields) {
+    if (f.field === 1 && f.data) result.state = decodeConversationState(f.data);
+    if (f.field === 2 && f.data) result.action = decodeConversationAction(f.data);
     if (f.field === 3 && f.data) result.model = decodeModelDetails(f.data);
+    if (f.field === 4 && f.data) result.mcpTools = decodeMcpTools(f.data);
     if (f.field === 5 && f.data) result.conversationId = protoStr(f.data);
-    if (f.field === 2 && f.data) result.action = decodeConversationAction(f.data);
-    if (f.field === 1 && f.data) result.state = decodeConversationState(f.data);
+  }
+  return result;
+}
+
+// McpTools: f1=repeated McpDescriptor (f1=serverName, f2=repeated tools)
+function decodeMcpTools(buf) {
+  const fields = protoWalkFields(buf);
+  const descriptors = [];
+  for (const f of fields) {
+    if (f.field === 1 && f.data) {
+      const inner = protoWalkFields(f.data);
+      const name = inner.find(x => x.field === 1 && x.data);
+      const tools = inner.filter(x => x.field === 2 && x.data).map(t => {
+        const tf = protoWalkFields(t.data);
+        const tname = tf.find(x => x.field === 1 && x.data);
+        return tname ? protoStr(tname.data) : null;
+      }).filter(Boolean);
+      descriptors.push({ server: name ? protoStr(name.data) : null, tools });
+    }
+  }
+  return descriptors;
+}
+
+// ExecClientMessage: f1=id(uint32), f2=shellResult, f3=writeResult, etc.
+function decodeExecClientMessage(buf) {
+  const fields = protoWalkFields(buf);
+  const result = { id: null, execId: null, resultType: "unknown" };
+  for (const f of fields) {
+    if (f.field === 1 && f.value !== undefined) result.id = f.value;
+    if (f.field === 15 && f.data) result.execId = protoStr(f.data);
+    // Detect result type by field number (oneof)
+    const resultTypes = { 2: "shellResult", 3: "writeResult", 4: "deleteResult", 5: "grepResult", 7: "readResult", 8: "lsResult", 9: "diagnosticsResult", 10: "requestContextResult", 11: "mcpResult", 14: "shellStream", 16: "backgroundShellSpawnResult" };
+    if (f.data && resultTypes[f.field]) result.resultType = resultTypes[f.field];
   }
   return result;
 }
@@ -307,15 +391,19 @@ function decodeModelDetails(buf) {
   return result;
 }
 
-// ConversationAction: f1 → f1 → f1=text, f2=uuid, f8=lexical_json
-//                    f1 → f2 → repeated f2=turns, f7=selected_context, f23=system_prompt
+// ConversationAction: f1=StartChatAction → f1=userMsg{f1=text,f2=uuid,f8=lexical}, f2=history{f2=contextFiles,f7=tools}
 function decodeConversationAction(buf) {
   const result = {};
   const topFields = protoWalkFields(buf);
 
-  // action.f1 wrapper
-  const f1 = topFields.find(f => f.field === 1 && f.data);
-  if (!f1) return result;
+  // action.f1 = StartChatAction wrapper
+  const f1 = topFields.find(f => f.field === 1 && f.data && f.data.length > 0);
+  if (!f1) {
+    // No StartChatAction — show which fields are present for debugging
+    const presentFields = topFields.map(f => `f${f.field}`);
+    if (presentFields.length > 0) result._fields = presentFields;
+    return result;
+  }
   const f1Fields = protoWalkFields(f1.data);
 
   // ── User message: action.f1.f1 ──────────────────────────────
@@ -422,61 +510,126 @@ function protoTreeToObj(buf, depth = 0) {
     }
   }
   return result;
-
-  return result;
 }
 
-// ConversationStateStructure: f1=root_prompt_messages_json(bytes[]), f8=turns(bytes[])
+// ConversationStateStructure: f1=root_prompt_messages_json(encrypted bytes), f3=todos, f8=turns, f10=mode
 function decodeConversationState(buf) {
   const fields = protoWalkFields(buf);
-  const messages = [], turns = [];
+  const turns = [], todos = [];
+  let mode = null, messageCount = 0;
   for (const f of fields) {
+    if (f.field === 10 && f.value !== undefined) {
+      const modes = ["unspecified", "agent", "ask", "plan", "debug", "triage"];
+      mode = modes[f.value] || `mode_${f.value}`;
+    }
     if (!f.data) continue;
     if (f.field === 1) {
-      // root_prompt_messages_json — each is a bytes field containing JSON string
-      const s = protoStr(f.data);
-      if (s) { try { messages.push(JSON.parse(s)); } catch { messages.push(s.substring(0, 500)); } }
+      // Encrypted bytes — just count, cannot decode
+      messageCount++;
     } else if (f.field === 8) {
-      // turns — bytes, try get readable strings
+      // f8 = repeated bytes (ConversationTurn OR encrypted blob)
+      // Encrypted turns: binary blobs that don't parse as valid proto strings
+      if (f.data.length === 32) continue; // 32-byte encrypted blob
       const inner = protoWalkFields(f.data);
-      const strs = inner.filter(x => x.data && protoStr(x.data)).map(x => protoStr(x.data)).filter(s => s.length > 5);
-      if (strs.length) turns.push(strs.slice(0, 5));
+      const strs = inner.filter(x => x.data).map(x => protoStr(x.data)).filter(s => s && s.length > 3);
+      if (strs.length) turns.push(strs.slice(0, 3));
+    } else if (f.field === 3) {
+      // f3 = repeated bytes (TodoItem OR encrypted blob)
+      // Encrypted: 32-byte binary (shows as 64-char hex in protoStr-reject path)
+      // TodoItem: f1=id(str), f2=content(str), f3=status(varint)
+      if (f.data.length === 32) {
+        // 32 bytes = encrypted blob, skip
+        continue;
+      }
+      const inner = protoWalkFields(f.data);
+      const id = inner.find(x => x.field === 1 && x.data);
+      const content = inner.find(x => x.field === 2 && x.data);
+      const status = inner.find(x => x.field === 3 && x.value !== undefined);
+      const idStr = id ? protoStr(id.data) : null;
+      const contentStr = content ? protoStr(content.data) : null;
+      // If neither id nor content is readable string, it's encrypted
+      if (!idStr && !contentStr) continue;
+      const statusMap = ["unspecified", "pending", "in_progress", "completed", "cancelled"];
+      todos.push({
+        id: idStr,
+        content: contentStr,
+        status: status ? (statusMap[status.value] || `status_${status.value}`) : null,
+      });
     }
   }
-  return { messages: messages.slice(0, 10), turns: turns.slice(0, 5) };
+  return { mode, messageCount, turns: turns.slice(0, 5), todos: todos.slice(0, 20) };
 }
 
 // ── Save per-chat JSON file ────────────────────────────────────
 function saveCursorLogFull(url, headers, buf) {
   try {
-    if (!url.includes("BidiAppend") || buf.length < 2 || buf[0] !== 0x1f || buf[1] !== 0x8b) return;
+    if (buf.length < 5) return;
 
-    const decompressed = zlib.gunzipSync(buf);
+    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 decoded = decodeBidiAppend(decompressed);
+    const endpoint = isBidiAppend ? "BidiAppend" : "RunPoll";
+    let decoded = {};
+    let userMessage = null;
 
-    const action = decoded?.agentMsg?.action || {};
-    const userMessage = action.textFull || action.text || null;
+    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;
+      }
+    }
+
+    // Fetch conversation history from local Cursor DB when AgentRunRequest detected
+    const conversationId = decoded?.agentMsg?.conversationId || null;
+    let conversation = null;
+    if (conversationId && decoded?.agentMsg?.type === "AgentRunRequest") {
+      conversation = readConversationFromDb(conversationId);
+    }
 
     const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const base = path.join(CURSOR_LOG_DIR, ts);
+    const base = path.join(CURSOR_LOG_DIR, `${ts}_${endpoint}`);
 
     // _chat.json — structured decoded
     fs.writeFileSync(`${base}_chat.json`, JSON.stringify({
       ts: new Date().toISOString(),
-      version: headers["x-cursor-client-version"],
-      sizeGzip: buf.length,
-      sizeRaw: decompressed.length,
+      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(decompressed);
+    const tree = protoTreeToObj(raw);
     fs.writeFileSync(`${base}_decoded.json`, JSON.stringify(tree, null, 2));
 
-    console.log(`[CURSOR] ${ts}_chat.json | type=${decoded?.agentMsg?.type} | msg=${userMessage || "(none)"}`);
+    const agentType = decoded?.agentMsg?.type || decoded?.requestId || "(none)";
+    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`);
   } catch (e) {
     console.error(`[CURSOR] decode error: ${e.message}`);
   }