vplex-memory 2.4.2 → 2.4.4

package/README.md

@@ -11,7 +11,7 @@ Works with Claude Code, Cursor, VS Code Copilot, Windsurf, Codex, and any MCP-co
   "mcpServers": {
     "vplex-memory": {
       "command": "npx",
-      "args": ["-y", "vplex-memory@2.4.1"]
+      "args": ["-y", "vplex-memory@2.4.2"]
     }
   }
 }
@@ -30,7 +30,7 @@ Add to `.mcp.json` in your project root or `~/.claude/settings.json` globally:
   "mcpServers": {
     "vplex-memory": {
       "command": "npx",
-      "args": ["-y", "vplex-memory@2.4.1"]
+      "args": ["-y", "vplex-memory@2.4.2"]
     }
   }
 }
@@ -46,7 +46,7 @@ Add to `.cursor/mcp.json`:
     "vplex-memory": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "vplex-memory@2.4.1"]
+      "args": ["-y", "vplex-memory@2.4.2"]
     }
   }
 }
@@ -62,7 +62,7 @@ Add to `.vscode/mcp.json`:
     "vplex-memory": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "vplex-memory@2.4.1"]
+      "args": ["-y", "vplex-memory@2.4.2"]
     }
   }
 }
@@ -78,7 +78,7 @@ Add to `~/.windsurf/mcp.json`:
     "vplex-memory": {
       "type": "stdio",
       "command": "npx",
-      "args": ["-y", "vplex-memory@2.4.1"]
+      "args": ["-y", "vplex-memory@2.4.2"]
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vplex-memory",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "VPLEX Memory MCP Server — persistent cross-session memory for AI coding tools",
   "type": "module",
   "bin": {

package/vplex-mcp-server.mjs

@@ -209,7 +209,7 @@ const TOKEN_CACHE_MS = 30_000; // re-read from disk every 30s
 const TOKEN_REFRESH_MARGIN_S = 120; // refresh if < 2 min until expiry
 
 // CLI auth flow state
-let cliAuthPending = null; // { sessionId, userCode, verificationUrl, pollInterval, expiresAt }
+let cliAuthPending = null; // { sessionId, userCode, autoApproveUrl, manualUrl, pollInterval, expiresAt }
 
 function getSessionPath() {
   return join(homedir(), ".vplex", "session.json");
@@ -373,44 +373,40 @@ function startCliAuthPolling(sessionId) {
 
 /**
  * Starts CLI auth flow if no token is available.
- * Returns an error message with the auth URL and code for the user.
+ * Uses the auto-approve page — if the user is logged in via browser cookie,
+ * the session is approved automatically (no manual code entry needed).
+ * Falls back to manual code entry URL if auto-approve is not possible.
  */
 async function startCliAuthFlow() {
   // Don't start if already pending
   if (cliAuthPending && Date.now() < cliAuthPending.expiresAt) {
-    return `Not authenticated. Open ${cliAuthPending.verificationUrl} and enter code: ${cliAuthPending.userCode}`;
+    return `Not authenticated. Open this URL to sign in:\n${cliAuthPending.autoApproveUrl}\n\nIf that doesn't work, open ${cliAuthPending.manualUrl} and enter code: ${cliAuthPending.userCode}`;
   }
 
   const result = await initCliAuth();
   if (!result?.cli_session_id) {
-    return "Not authenticated. Please log in via VPLEX Desktop App.";
+    return `Not authenticated. Auth service unavailable — please try again in a moment, or sign in at ${WEB_URL}/auth/signin manually.`;
   }
 
   const pollInterval = startCliAuthPolling(result.cli_session_id);
 
+  const autoApproveUrl = `${WEB_URL}/auth/device-approve?session_id=${result.cli_session_id}`;
+  const manualUrl = result.verification_url || `${WEB_URL}/auth/cli`;
+
   cliAuthPending = {
     sessionId: result.cli_session_id,
     userCode: result.user_code,
-    verificationUrl: result.verification_url || `${WEB_URL}/auth/cli`,
+    autoApproveUrl,
+    manualUrl,
     pollInterval,
     expiresAt: Date.now() + (result.expires_in || 600) * 1000,
   };
 
-  return `Not authenticated. Open ${cliAuthPending.verificationUrl} and enter code: ${cliAuthPending.userCode}`;
+  return `Not authenticated. Open this URL to sign in:\n${autoApproveUrl}\n\nIf that doesn't work, open ${manualUrl} and enter code: ${cliAuthPending.userCode}`;
 }
 
 // ── Project Identification ──────────────────────────────────────────
 
-function hashString(str) {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = ((hash << 5) - hash) + char;
-    hash |= 0;
-  }
-  return Math.abs(hash).toString(36);
-}
-
 // Detect project root: env override > .git traversal > cwd fallback
 function detectProjectRoot() {
   // Explicit override via env (set in MCP config)
@@ -435,10 +431,98 @@ function detectProjectRoot() {
   return process.cwd();
 }
 
-const detectedRoot = detectProjectRoot();
-const projectHash = hashString(detectedRoot);
-const projectName = detectedRoot.replace(/\\/g, "/").split("/").pop() || detectedRoot;
-const projectPath = detectedRoot;
+/**
+ * Read or create the project identifier from .vplex/project-id.
+ *
+ * This file is the single source of truth for project identity.
+ * It survives folder renames, git remote changes, moves, and re-clones
+ * (if committed to the repo).
+ *
+ * Priority:
+ *   1. .vplex/project-id file exists → read and use it
+ *   2. File doesn't exist → generate new ID, create .vplex/ dir + file
+ */
+function resolveProjectId(projectRoot) {
+  const vplexDir = join(projectRoot, ".vplex");
+  const idFile = join(vplexDir, "project-id");
+
+  // Try to read existing ID
+  try {
+    const id = readFileSync(idFile, "utf-8").trim();
+    if (id.length >= 4 && id.length <= 64) {
+      return id;
+    }
+    // Invalid content — regenerate
+  } catch {
+    // File doesn't exist — create it
+  }
+
+  // Generate new project ID
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 12; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+
+  try {
+    mkdirSync(vplexDir, { recursive: true });
+    writeFileSync(idFile, id + "\n", { encoding: "utf-8" });
+    process.stderr.write(`[vplex-mcp] Created .vplex/project-id: ${id}\n`);
+  } catch (err) {
+    process.stderr.write(`[vplex-mcp] Warning: could not write .vplex/project-id: ${err.message}\n`);
+  }
+
+  return id;
+}
+
+let detectedRoot = detectProjectRoot();
+let projectHash = resolveProjectId(detectedRoot);
+let projectName = detectedRoot.replace(/\\/g, "/").split("/").pop() || detectedRoot;
+let projectPath = detectedRoot;
+process.stderr.write(`[vplex-mcp] Project: ${projectName} | id: ${projectHash} | root: ${detectedRoot}\n`);
+
+/**
+ * Re-detect project from a new root path (e.g. from MCP client roots).
+ * Walks up from the given path looking for .git, then resolves project ID.
+ */
+function reinitProject(rootUri) {
+  let newRoot = rootUri;
+  // Convert file:// URI to path
+  if (newRoot.startsWith("file:///")) {
+    newRoot = newRoot.slice(8); // file:///C:/foo → C:/foo
+    // On Windows, file:///C:/foo → C:/foo (keep drive letter)
+    // On Unix, file:///home/user → /home/user
+    if (!/^\//.test(newRoot) && /^[a-zA-Z]:/.test(newRoot)) {
+      // Windows path — already correct
+    } else if (!newRoot.startsWith("/")) {
+      newRoot = "/" + newRoot;
+    }
+  } else if (newRoot.startsWith("file://")) {
+    newRoot = newRoot.slice(7);
+  }
+  // Decode URI components (spaces, special chars)
+  newRoot = decodeURIComponent(newRoot);
+
+  // Walk up from new root looking for .git
+  let dir = newRoot;
+  const rootDir = parse(dir).root;
+  while (dir !== rootDir) {
+    try {
+      statSync(join(dir, ".git"));
+      newRoot = dir;
+      break;
+    } catch { /* continue */ }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  detectedRoot = newRoot;
+  projectHash = resolveProjectId(detectedRoot);
+  projectName = detectedRoot.replace(/\\/g, "/").split("/").pop() || detectedRoot;
+  projectPath = detectedRoot;
+  process.stderr.write(`[vplex-mcp] Project updated: ${projectName} | id: ${projectHash} | root: ${detectedRoot}\n`);
+}
 
 // ── HTTP Helper ─────────────────────────────────────────────────────
 
@@ -684,7 +768,7 @@ const TOOLS = [
   },
   {
     name: "memory_signin",
-    description: "Sign in to VPLEX Memory. Starts the browser-based auth flow and returns a URL + code to enter.",
+    description: "Sign in to VPLEX Memory. Opens the browser-based auth flow — if already logged in via browser, approval is automatic (no code needed). Returns a URL to open.",
     inputSchema: { type: "object", properties: {} },
   },
   {
@@ -1160,9 +1244,14 @@ async function handleToolCall(name, args) {
         const user = session?.user?.email || session?.user?.name || "unknown";
         return { content: [{ type: "text", text: `Already signed in as ${user}. Use memory_logout first to switch accounts.` }] };
       }
-      // Start the CLI auth flow
+      // Start the CLI auth flow with auto-approve URL
       const authMessage = await startCliAuthFlow();
-      return { content: [{ type: "text", text: authMessage }] };
+      return {
+        content: [{
+          type: "text",
+          text: `${authMessage}\n\nOnce you sign in via the browser, this session will be automatically authenticated. The polling runs in the background — just try any memory tool again after signing in.`,
+        }],
+      };
     }
 
     case "memory_auth_status": {
@@ -1218,22 +1307,45 @@ async function handleRequest(request) {
 
   // MCP notifications (no id, or notifications/* prefix) — never respond
   if (id === undefined || id === null || method.startsWith("notifications/")) {
+    // Handle roots/list_changed — client workspace changed
+    if (method === "notifications/roots/list_changed" && params?.roots?.length > 0) {
+      const rootUri = params.roots[0].uri || params.roots[0];
+      if (typeof rootUri === "string" && rootUri.length > 0) {
+        reinitProject(rootUri);
+      }
+    }
     return null;
   }
 
   try {
     switch (method) {
       case "initialize":
+        // Read workspace roots from client (e.g. VS Code workspace folders)
+        if (params?.roots?.length > 0) {
+          const rootUri = params.roots[0].uri || params.roots[0];
+          process.stderr.write(`[vplex-mcp] Client root: ${typeof rootUri === "string" ? rootUri : JSON.stringify(rootUri)}\n`);
+          if (typeof rootUri === "string" && rootUri.length > 0) {
+            reinitProject(rootUri);
+          }
+        } else if (params?.workspaceFolders?.length > 0) {
+          // Some clients send workspaceFolders instead of roots
+          const folder = params.workspaceFolders[0].uri || params.workspaceFolders[0];
+          if (typeof folder === "string" && folder.length > 0) {
+            reinitProject(folder);
+          }
+        }
         return {
           jsonrpc: "2.0", id,
           result: {
             protocolVersion: "2024-11-05",
-            capabilities: { tools: {} },
+            capabilities: { tools: {}, roots: { listChanged: false } },
             serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
           },
         };
 
       case "initialized":
+        // After initialization, request workspace roots from the client
+        requestRootsFromClient();
         return null;
 
       case "tools/list":
@@ -1257,6 +1369,38 @@ async function handleRequest(request) {
   }
 }
 
+// ── Server-to-Client Requests ───────────────────────────────────────
+
+let nextRequestId = 1;
+const pendingRequests = new Map(); // id → { resolve, reject, timer }
+
+function sendClientRequest(method, params = {}) {
+  return new Promise((resolve, reject) => {
+    const id = `srv-${nextRequestId++}`;
+    const timer = setTimeout(() => {
+      pendingRequests.delete(id);
+      reject(new Error(`Client request ${method} timed out`));
+    }, 5000);
+    pendingRequests.set(id, { resolve, reject, timer });
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+  });
+}
+
+async function requestRootsFromClient() {
+  try {
+    const result = await sendClientRequest("roots/list");
+    if (result?.roots?.length > 0) {
+      const rootUri = result.roots[0].uri || result.roots[0];
+      process.stderr.write(`[vplex-mcp] Got root from client: ${typeof rootUri === "string" ? rootUri : JSON.stringify(rootUri)}\n`);
+      if (typeof rootUri === "string" && rootUri.length > 0) {
+        reinitProject(rootUri);
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`[vplex-mcp] roots/list not supported by client: ${err.message}\n`);
+  }
+}
+
 // ── stdio Communication Loop ────────────────────────────────────────
 
 const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
@@ -1265,8 +1409,18 @@ rl.on("line", async (line) => {
   if (!line.trim()) return;
 
   try {
-    const request = JSON.parse(line);
-    const response = await handleRequest(request);
+    const msg = JSON.parse(line);
+
+    // Check if this is a response to a server-initiated request
+    if (msg.id && pendingRequests.has(msg.id)) {
+      const { resolve, timer } = pendingRequests.get(msg.id);
+      clearTimeout(timer);
+      pendingRequests.delete(msg.id);
+      resolve(msg.result ?? null);
+      return;
+    }
+
+    const response = await handleRequest(msg);
     if (response !== null) {
       // Write to stdout only — stderr is reserved for diagnostics
       process.stdout.write(JSON.stringify(response) + "\n");