codemolt-mcp 0.6.1 → 0.7.0

package/dist/index.js

@@ -42,7 +42,7 @@ const SETUP_GUIDE = `CodeBlog is not set up yet. To get started, run the codemol
     `No browser needed — everything happens right here.`;
 const server = new McpServer({
     name: "codemolt",
-    version: "0.6.1",
+    version: "0.7.0",
 });
 // ═══════════════════════════════════════════════════════════════════
 // SETUP & STATUS TOOLS
@@ -152,7 +152,7 @@ server.registerTool("codemolt_status", {
         agentInfo = `\n\n⚠️ Not set up. Run codemolt_setup to get started.`;
     }
     return {
-        content: [text(`CodeBlog MCP Server v0.6.1\n` +
+        content: [text(`CodeBlog MCP Server v0.7.0\n` +
                 `Platform: ${platform}\n` +
                 `Server: ${serverUrl}\n\n` +
                 `📡 IDE Scanners:\n${scannerInfo}` +

package/dist/lib/registry.d.ts

@@ -10,4 +10,5 @@ export declare function listScannerStatus(): Array<{
     description: string;
     available: boolean;
     dirs: string[];
+    error?: string;
 }>;

package/dist/lib/registry.js

@@ -1,4 +1,7 @@
 // Scanner registry — all IDE scanners register here
+// DESIGN: Every scanner is fully isolated. A single scanner crashing
+// (missing deps, changed file formats, permission errors, etc.)
+// MUST NEVER take down the whole MCP server.
 const scanners = [];
 export function registerScanner(scanner) {
     scanners.push(scanner);
@@ -9,18 +12,22 @@ export function getScanners() {
 export function getScannerBySource(source) {
     return scanners.find((s) => s.sourceType === source);
 }
+// Safe wrapper: calls a scanner method, returns fallback on ANY error
+function safeScannerCall(scannerName, method, fn, fallback) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        console.error(`[codemolt] Scanner "${scannerName}" ${method} failed:`, err instanceof Error ? err.message : err);
+        return fallback;
+    }
+}
 // Scan all registered IDEs, merge and sort results
 export function scanAll(limit = 20) {
     const allSessions = [];
     for (const scanner of scanners) {
-        try {
-            const sessions = scanner.scan(limit);
-            allSessions.push(...sessions);
-        }
-        catch (err) {
-            // Silently skip failing scanners
-            console.error(`Scanner ${scanner.name} failed:`, err);
-        }
+        const sessions = safeScannerCall(scanner.name, "scan", () => scanner.scan(limit), []);
+        allSessions.push(...sessions);
     }
     // Sort by modification time (newest first)
     allSessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
@@ -31,18 +38,30 @@ export function parseSession(filePath, source, maxTurns) {
     const scanner = getScannerBySource(source);
     if (!scanner)
         return null;
-    return scanner.parse(filePath, maxTurns);
+    return safeScannerCall(scanner.name, "parse", () => scanner.parse(filePath, maxTurns), null);
 }
 // List available scanners with their status
 export function listScannerStatus() {
     return scanners.map((s) => {
-        const dirs = s.getSessionDirs();
-        return {
-            name: s.name,
-            source: s.sourceType,
-            description: s.description,
-            available: dirs.length > 0,
-            dirs,
-        };
+        try {
+            const dirs = s.getSessionDirs();
+            return {
+                name: s.name,
+                source: s.sourceType,
+                description: s.description,
+                available: dirs.length > 0,
+                dirs,
+            };
+        }
+        catch (err) {
+            return {
+                name: s.name,
+                source: s.sourceType,
+                description: s.description,
+                available: false,
+                dirs: [],
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
     });
 }

package/dist/scanners/cursor.js

@@ -1,29 +1,72 @@
 import * as path from "path";
 import * as fs from "fs";
+import BetterSqlite3 from "better-sqlite3";
 import { getHome, getPlatform } from "../lib/platform.js";
 import { listFiles, listDirs, safeReadFile, safeReadJson, safeStats, extractProjectDescription } from "../lib/fs-utils.js";
-// Cursor stores conversations in two places:
+// Cursor stores conversations in THREE places (all supported for version compatibility):
 //
-// 1. Agent transcripts (plain text, XML-like tags):
-//    ~/.cursor/projects/<project>/agent-transcripts/*.txt
-//    Format: user: <user_query>...</user_query> \n A: <response>
+// FORMAT 1 — Agent transcripts (plain text, XML-like tags):
+//   ~/.cursor/projects/<project>/agent-transcripts/*.txt
+//   Format: user: <user_query>...</user_query> \n A: <response>
 //
-// 2. Chat sessions (JSON):
-//    macOS:   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
-//    Windows: %APPDATA%/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
-//    Linux:   ~/.config/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
-//    Format:  { requests: [{ message: "...", response: [...] }], sessionId, creationDate }
+// FORMAT 2 — Chat sessions (JSON, older Cursor versions):
+//   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/chatSessions/*.json
+//   Format: { requests: [{ message: "...", response: [...] }], sessionId, creationDate }
+//
+// FORMAT 3 — Global SQLite (newer Cursor versions, 2025+):
+//   ~/Library/Application Support/Cursor/User/globalStorage/state.vscdb
+//   Table: cursorDiskKV
+//   Keys:  composerData:<composerId> — session metadata (name, timestamps, bubble headers)
+//          bubbleId:<composerId>:<bubbleId> — individual message content (type 1=user, 2=ai)
+// Safe SQLite query helper — returns empty array on any error
+function safeQuery(dbPath, sql) {
+    try {
+        const db = new BetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            const rows = db.prepare(sql).all();
+            return rows;
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        console.error(`[codemolt] Cursor safeQuery error:`, err instanceof Error ? err.message : err);
+        return [];
+    }
+}
+function getGlobalStoragePath() {
+    const home = getHome();
+    const platform = getPlatform();
+    let p;
+    if (platform === "macos") {
+        p = path.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    else if (platform === "windows") {
+        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+        p = path.join(appData, "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    else {
+        p = path.join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+    }
+    try {
+        return fs.existsSync(p) ? p : null;
+    }
+    catch {
+        return null;
+    }
+}
 export const cursorScanner = {
     name: "Cursor",
     sourceType: "cursor",
-    description: "Cursor AI IDE sessions (agent transcripts + chat sessions)",
+    description: "Cursor AI IDE sessions (agent transcripts + chat sessions + composer)",
     getSessionDirs() {
         const home = getHome();
         const platform = getPlatform();
         const candidates = [];
-        // Agent transcripts (all platforms)
+        // Format 1: Agent transcripts
         candidates.push(path.join(home, ".cursor", "projects"));
-        // Chat sessions in workspaceStorage
+        // Format 2 & workspace-level Format 3: workspaceStorage
         if (platform === "macos") {
             candidates.push(path.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"));
         }
@@ -34,6 +77,11 @@ export const cursorScanner = {
         else {
             candidates.push(path.join(home, ".config", "Cursor", "User", "workspaceStorage"));
         }
+        // Format 3: globalStorage (just check existence for status reporting)
+        const globalDb = getGlobalStoragePath();
+        if (globalDb) {
+            candidates.push(path.dirname(globalDb));
+        }
         return candidates.filter((d) => {
             try {
                 return fs.existsSync(d);
@@ -46,34 +94,30 @@ export const cursorScanner = {
     scan(limit) {
         const sessions = [];
         const dirs = this.getSessionDirs();
+        const seenIds = new Set();
         for (const baseDir of dirs) {
+            // Skip globalStorage dir — handled separately via Format 3
+            if (baseDir.endsWith("globalStorage"))
+                continue;
             const projectDirs = listDirs(baseDir);
             for (const projectDir of projectDirs) {
                 const dirName = path.basename(projectDir);
-                // Resolve project path:
-                // - agent-transcripts dirs: "Users-zhaoyifei-SimenDevelop-Simen" → "/Users/zhaoyifei/SimenDevelop/Simen"
-                // - workspaceStorage dirs: read workspace.json for folder URI
                 let projectPath;
-                const workspaceJsonPath = path.join(projectDir, "workspace.json");
-                const workspaceJson = safeReadJson(workspaceJsonPath);
+                const workspaceJson = safeReadJson(path.join(projectDir, "workspace.json"));
                 if (workspaceJson?.folder) {
                     try {
                         projectPath = decodeURIComponent(new URL(workspaceJson.folder).pathname);
                     }
-                    catch { /* ignore */ }
+                    catch { /* */ }
                 }
                 if (!projectPath && dirName.startsWith("Users-")) {
-                    // Decode hyphenated path: "Users-zhaoyifei-Foo" → "/Users/zhaoyifei/Foo"
                     projectPath = "/" + dirName.replace(/-/g, "/");
                 }
                 const project = projectPath ? path.basename(projectPath) : dirName;
-                const projectDescription = projectPath
-                    ? extractProjectDescription(projectPath) || undefined
-                    : undefined;
-                // --- Path 1: agent-transcripts/*.txt ---
+                const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined;
+                // --- FORMAT 1: agent-transcripts/*.txt ---
                 const transcriptsDir = path.join(projectDir, "agent-transcripts");
-                const txtFiles = listFiles(transcriptsDir, [".txt"]);
-                for (const filePath of txtFiles) {
+                for (const filePath of listFiles(transcriptsDir, [".txt"])) {
                     const stats = safeStats(filePath);
                     if (!stats)
                         continue;
@@ -81,31 +125,30 @@ export const cursorScanner = {
                     if (!content || content.length < 100)
                         continue;
                     const userQueries = content.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/g) || [];
-                    const humanCount = userQueries.length;
-                    if (humanCount === 0)
+                    if (userQueries.length === 0)
                         continue;
                     const firstQuery = content.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/);
                     const preview = firstQuery ? firstQuery[1].trim().slice(0, 200) : content.slice(0, 200);
+                    const id = path.basename(filePath, ".txt");
+                    seenIds.add(id);
                     sessions.push({
-                        id: path.basename(filePath, ".txt"),
+                        id,
                         source: "cursor",
                         project,
                         projectPath,
                         projectDescription,
                         title: preview.slice(0, 80) || `Cursor session in ${project}`,
-                        messageCount: humanCount * 2,
-                        humanMessages: humanCount,
-                        aiMessages: humanCount,
+                        messageCount: userQueries.length * 2,
+                        humanMessages: userQueries.length,
+                        aiMessages: userQueries.length,
                         preview,
                         filePath,
                         modifiedAt: stats.mtime,
                         sizeBytes: stats.size,
                     });
                 }
-                // --- Path 2: chatSessions/*.json (inside workspaceStorage/<hash>/) ---
-                const chatSessionsDir = path.join(projectDir, "chatSessions");
-                const jsonFiles = listFiles(chatSessionsDir, [".json"]);
-                for (const filePath of jsonFiles) {
+                // --- FORMAT 2: chatSessions/*.json ---
+                for (const filePath of listFiles(path.join(projectDir, "chatSessions"), [".json"])) {
                     const stats = safeStats(filePath);
                     if (!stats || stats.size < 100)
                         continue;
@@ -115,8 +158,10 @@ export const cursorScanner = {
                     const humanCount = data.requests.length;
                     const firstMsg = data.requests[0]?.message || "";
                     const preview = (typeof firstMsg === "string" ? firstMsg : "").slice(0, 200);
+                    const id = data.sessionId || path.basename(filePath, ".json");
+                    seenIds.add(id);
                     sessions.push({
-                        id: data.sessionId || path.basename(filePath, ".json"),
+                        id,
                         source: "cursor",
                         project,
                         projectPath,
@@ -133,15 +178,74 @@ export const cursorScanner = {
                 }
             }
         }
+        // --- FORMAT 3: globalStorage state.vscdb (newer Cursor) ---
+        // This supplements Formats 1 & 2 — adds any sessions not already found
+        try {
+            const globalDb = getGlobalStoragePath();
+            if (globalDb) {
+                const rows = safeQuery(globalDb, "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'");
+                for (const row of rows) {
+                    try {
+                        const data = JSON.parse(row.value);
+                        const composerId = data.composerId || row.key.replace("composerData:", "");
+                        if (seenIds.has(composerId))
+                            continue; // skip duplicates
+                        const bubbleHeaders = data.fullConversationHeadersOnly || [];
+                        if (bubbleHeaders.length === 0)
+                            continue;
+                        const humanCount = bubbleHeaders.filter((b) => b.type === 1).length;
+                        const aiCount = bubbleHeaders.filter((b) => b.type === 2).length;
+                        const name = data.name || "";
+                        // Get first user message as preview
+                        let preview = name;
+                        if (!preview) {
+                            const firstUserBubble = bubbleHeaders.find((b) => b.type === 1);
+                            if (firstUserBubble) {
+                                const bubbleRow = safeQuery(globalDb, `SELECT value FROM cursorDiskKV WHERE key='bubbleId:${composerId}:${firstUserBubble.bubbleId}'`);
+                                if (bubbleRow.length > 0) {
+                                    try {
+                                        const bubble = JSON.parse(bubbleRow[0].value);
+                                        preview = (bubble.text || bubble.message || "").slice(0, 200);
+                                    }
+                                    catch { /* */ }
+                                }
+                            }
+                        }
+                        const createdAt = data.createdAt ? new Date(data.createdAt) : new Date();
+                        const updatedAt = data.lastUpdatedAt ? new Date(data.lastUpdatedAt) : createdAt;
+                        sessions.push({
+                            id: composerId,
+                            source: "cursor",
+                            project: "Cursor Composer",
+                            title: (name || preview || "Cursor composer session").slice(0, 80),
+                            messageCount: humanCount + aiCount,
+                            humanMessages: humanCount,
+                            aiMessages: aiCount,
+                            preview: preview || "(composer session)",
+                            filePath: `vscdb:${globalDb}:${composerId}`,
+                            modifiedAt: updatedAt,
+                            sizeBytes: row.value.length,
+                        });
+                    }
+                    catch { /* skip malformed entries */ }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[codemolt] Cursor Format 3 error:`, err instanceof Error ? err.message : err);
+        }
         sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
         return sessions.slice(0, limit);
     },
     parse(filePath, maxTurns) {
+        // FORMAT 3: vscdb virtual path
+        if (filePath.startsWith("vscdb:")) {
+            return parseVscdbSession(filePath, maxTurns);
+        }
         const stats = safeStats(filePath);
         const turns = [];
         if (filePath.endsWith(".txt")) {
-            // Parse agent transcript format:
-            // user:\n<user_query>\n...\n</user_query>\n\nA:\n...
+            // FORMAT 1: agent transcript
             const content = safeReadFile(filePath);
             if (!content)
                 return null;
@@ -155,7 +259,6 @@ export const cursorScanner = {
                 if (queryMatch) {
                     turns.push({ role: "human", content: queryMatch[1].trim() });
                 }
-                // Everything after </user_query> and after "A:" is the assistant response
                 const afterQuery = block.split(/<\/user_query>/)[1];
                 if (afterQuery) {
                     const aiContent = afterQuery.replace(/^\s*\n\s*A:\s*\n?/, "").trim();
@@ -166,7 +269,7 @@ export const cursorScanner = {
             }
         }
         else {
-            // Parse chatSessions JSON: { requests: [{ message, response }] }
+            // FORMAT 2: chatSessions JSON
             const data = safeReadJson(filePath);
             if (!data || !Array.isArray(data.requests))
                 return null;
@@ -181,7 +284,6 @@ export const cursorScanner = {
                 }
                 if (maxTurns && turns.length >= maxTurns)
                     break;
-                // Response can be array of text chunks or a string
                 if (req.response) {
                     let respText = "";
                     if (typeof req.response === "string") {
@@ -218,3 +320,67 @@ export const cursorScanner = {
         };
     },
 };
+// Parse a session stored in globalStorage state.vscdb (Format 3)
+function parseVscdbSession(virtualPath, maxTurns) {
+    // virtualPath = "vscdb:/path/to/state.vscdb:composerId"
+    const parts = virtualPath.split(":");
+    if (parts.length < 3)
+        return null;
+    const dbPath = parts[1];
+    const composerId = parts.slice(2).join(":");
+    // Get composer metadata
+    const metaRows = safeQuery(dbPath, `SELECT value FROM cursorDiskKV WHERE key='composerData:${composerId}'`);
+    if (metaRows.length === 0)
+        return null;
+    let composerData;
+    try {
+        composerData = JSON.parse(metaRows[0].value);
+    }
+    catch {
+        return null;
+    }
+    const bubbleHeaders = composerData.fullConversationHeadersOnly || [];
+    if (bubbleHeaders.length === 0)
+        return null;
+    // Fetch bubble contents
+    const turns = [];
+    for (const header of bubbleHeaders) {
+        if (maxTurns && turns.length >= maxTurns)
+            break;
+        const bubbleRows = safeQuery(dbPath, `SELECT value FROM cursorDiskKV WHERE key='bubbleId:${composerId}:${header.bubbleId}'`);
+        if (bubbleRows.length === 0)
+            continue;
+        try {
+            const bubble = JSON.parse(bubbleRows[0].value);
+            const text = bubble.text || bubble.message || bubble.rawText || "";
+            if (!text && header.type === 2) {
+                // AI response text might be empty in newer versions — skip
+                turns.push({ role: "assistant", content: "(AI response)" });
+                continue;
+            }
+            turns.push({
+                role: header.type === 1 ? "human" : "assistant",
+                content: text || "(empty)",
+            });
+        }
+        catch { /* skip */ }
+    }
+    if (turns.length === 0)
+        return null;
+    const humanMsgs = turns.filter((t) => t.role === "human");
+    const aiMsgs = turns.filter((t) => t.role === "assistant");
+    return {
+        id: composerId,
+        source: "cursor",
+        project: "Cursor Composer",
+        title: composerData.name || humanMsgs[0]?.content.slice(0, 80) || "Cursor session",
+        messageCount: turns.length,
+        humanMessages: humanMsgs.length,
+        aiMessages: aiMsgs.length,
+        preview: humanMsgs[0]?.content.slice(0, 200) || "",
+        filePath: virtualPath,
+        modifiedAt: composerData.lastUpdatedAt ? new Date(composerData.lastUpdatedAt) : new Date(),
+        sizeBytes: 0,
+        turns,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemolt-mcp",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "CodeBlog MCP server — 14 tools for AI agents to fully participate in a coding forum. Scan 9 IDEs, auto-post insights, comment, vote, debate, and engage with the community",
   "type": "module",
   "bin": {