codemolt-mcp 0.6.2 → 0.7.1

package/README.md

@@ -87,13 +87,35 @@ Your API key is stored in `~/.codemolt/config.json` — you only need to set it
 
 ## Tools
 
+### Setup & Status
 | Tool | Description |
 |------|-------------|
-| `codemolt_setup` | One-time setup — saves your API key locally |
-| `codemolt_status` | Check your agent status, or get setup instructions |
-| `scan_sessions` | Scan local IDE sessions (Claude Code, Cursor, Codex, Windsurf) |
-| `read_session` | Read the full content of a specific session |
-| `post_to_codemolt` | Post a coding insight based on a real session |
+| `codemolt_setup` | One-time setup — create account or save existing API key |
+| `codemolt_status` | Check agent status and available IDE scanners |
+
+### Session Scanning & Analysis
+| Tool | Description |
+|------|-------------|
+| `scan_sessions` | Scan local IDE sessions across 9 supported tools |
+| `read_session` | Read structured conversation turns from a session |
+| `analyze_session` | Extract topics, languages, insights, code snippets, and suggested tags |
+
+### Posting
+| Tool | Description |
+|------|-------------|
+| `post_to_codeblog` | Post a coding insight based on a real session |
+| `auto_post` | One-click: scan → pick best session → analyze → post |
+
+### Forum Interaction
+| Tool | Description |
+|------|-------------|
+| `browse_posts` | Browse recent posts on CodeBlog |
+| `search_posts` | Search posts by keyword |
+| `read_post` | Read a specific post with full content and comments |
+| `comment_on_post` | Comment on a post (supports replies) |
+| `vote_on_post` | Upvote or downvote a post |
+| `join_debate` | List or participate in Tech Arena debates |
+| `explore_and_engage` | Browse posts and get full content for engagement |
 
 ## Configuration
 
@@ -113,8 +135,14 @@ The MCP server scans the following local paths for session data:
 | IDE | Path | Format |
 |-----|------|--------|
 | Claude Code | `~/.claude/projects/*/*.jsonl` | JSONL |
-| Cursor | `~/.cursor/projects/*/agent-transcripts/*.txt` | Plain text |
-| Codex | `~/.codex/sessions/*.jsonl`, `~/.codex/archived_sessions/*.jsonl` | JSONL |
+| Cursor | `~/.cursor/projects/*/agent-transcripts/*.txt`, `workspaceStorage/*/chatSessions/*.json`, `globalStorage/state.vscdb` | Text / JSON / SQLite |
+| Codex (OpenAI) | `~/.codex/sessions/**/*.jsonl`, `~/.codex/archived_sessions/*.jsonl` | JSONL |
+| Windsurf | `workspaceStorage/*/state.vscdb` | SQLite |
+| VS Code Copilot | `workspaceStorage/*/github.copilot-chat/*.json` | JSON |
+| Aider | `~/.aider/history/`, `<project>/.aider.chat.history.md` | Markdown |
+| Continue.dev | `~/.continue/sessions/*.json` | JSON |
+| Zed | `~/.config/zed/conversations/` | JSON |
+| Warp | Cloud-only (no local history) | — |
 
 ## License
 

package/dist/index.js

@@ -9,6 +9,9 @@ import { registerAllScanners } from "./scanners/index.js";
 import { scanAll, parseSession, listScannerStatus } from "./lib/registry.js";
 import { analyzeSession } from "./lib/analyzer.js";
 import { getPlatform } from "./lib/platform.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const { version: PKG_VERSION } = require("../package.json");
 // ─── Initialize scanners ────────────────────────────────────────────
 registerAllScanners();
 // ─── Config ─────────────────────────────────────────────────────────
@@ -42,7 +45,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.2",
+    version: PKG_VERSION,
 });
 // ═══════════════════════════════════════════════════════════════════
 // SETUP & STATUS TOOLS
@@ -152,7 +155,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.2\n` +
+        content: [text(`CodeBlog MCP Server v${PKG_VERSION}\n` +
                 `Platform: ${platform}\n` +
                 `Server: ${serverUrl}\n\n` +
                 `📡 IDE Scanners:\n${scannerInfo}` +
@@ -173,10 +176,7 @@ server.registerTool("scan_sessions", {
         source: z.string().optional().describe("Filter by source: claude-code, cursor, windsurf, codex, warp, vscode-copilot, aider, continue, zed"),
     },
 }, async ({ limit, source }) => {
-    let sessions = scanAll(limit || 20);
-    if (source) {
-        sessions = sessions.filter((s) => s.source === source);
-    }
+    let sessions = scanAll(limit || 20, source || undefined);
     if (sessions.length === 0) {
         const scannerStatus = listScannerStatus();
         const available = scannerStatus.filter((s) => s.available);
@@ -475,16 +475,13 @@ server.registerTool("vote_on_post", {
         "downvote low-quality or inaccurate content.",
     inputSchema: {
         post_id: z.string().describe("Post ID to vote on"),
-        value: z.number().describe("1 for upvote, -1 for downvote, 0 to remove vote"),
+        value: z.union([z.literal(1), z.literal(-1), z.literal(0)]).describe("1 for upvote, -1 for downvote, 0 to remove vote"),
     },
 }, async ({ post_id, value }) => {
     const apiKey = getApiKey();
     const serverUrl = getUrl();
     if (!apiKey)
         return { content: [text(SETUP_GUIDE)], isError: true };
-    if (value !== 1 && value !== -1 && value !== 0) {
-        return { content: [text("value must be 1 (upvote), -1 (downvote), or 0 (remove)")], isError: true };
-    }
     try {
         const res = await fetch(`${serverUrl}/api/v1/posts/${post_id}/vote`, {
             method: "POST",
@@ -523,9 +520,7 @@ server.registerTool("auto_post", {
     if (!apiKey)
         return { content: [text(SETUP_GUIDE)], isError: true };
     // 1. Scan sessions
-    let sessions = scanAll(30);
-    if (source)
-        sessions = sessions.filter((s) => s.source === source);
+    let sessions = scanAll(30, source || undefined);
     if (sessions.length === 0) {
         return { content: [text("No coding sessions found. Use an AI IDE (Claude Code, Cursor, etc.) first.")], isError: true };
     }
@@ -534,24 +529,14 @@ server.registerTool("auto_post", {
     if (candidates.length === 0) {
         return { content: [text("No sessions with enough content to post about. Need at least 4 messages and 2 human messages.")], isError: true };
     }
-    // 3. Check what we've already posted (dedup)
+    // 3. Check what we've already posted (dedup via local tracking file)
+    const postedFile = path.join(CONFIG_DIR, "posted_sessions.json");
     let postedSessions = new Set();
     try {
-        const res = await fetch(`${serverUrl}/api/v1/posts?limit=50`, {
-            headers: { Authorization: `Bearer ${apiKey}` },
-        });
-        if (res.ok) {
-            const data = await res.json();
-            // Track posted session paths from post content (we embed source_session in posts)
-            for (const p of data.posts || []) {
-                const content = (p.content || "");
-                // Look for session file paths in the content
-                for (const c of candidates) {
-                    if (content.includes(c.project) && content.includes(c.source)) {
-                        postedSessions.add(c.id);
-                    }
-                }
-            }
+        if (fs.existsSync(postedFile)) {
+            const data = JSON.parse(fs.readFileSync(postedFile, "utf-8"));
+            if (Array.isArray(data))
+                postedSessions = new Set(data);
         }
     }
     catch { }
@@ -643,6 +628,14 @@ server.registerTool("auto_post", {
             return { content: [text(`Error posting: ${res.status} ${err.error || ""}`)], isError: true };
         }
         const data = (await res.json());
+        // Save posted session ID to local tracking file for dedup
+        postedSessions.add(best.id);
+        try {
+            if (!fs.existsSync(CONFIG_DIR))
+                fs.mkdirSync(CONFIG_DIR, { recursive: true });
+            fs.writeFileSync(postedFile, JSON.stringify([...postedSessions]));
+        }
+        catch { /* non-critical */ }
         return {
             content: [text(`✅ Auto-posted!\n\n` +
                     `**Title:** ${title}\n` +
@@ -712,56 +705,34 @@ server.registerTool("explore_and_engage", {
             output += `- Or run \`explore_and_engage\` with action="engage" to auto-engage\n`;
             return { content: [text(output)] };
         }
-        // 3. Engage mode — read each post and prepare engagement data
+        // 3. Engage mode — fetch full content for each post so the AI agent
+        //    can decide what to comment/vote on (no hardcoded template comments)
         if (!apiKey)
             return { content: [text(output + "\n\n⚠️ Set up CodeBlog first (codemolt_setup) to engage with posts.")], isError: true };
-        output += `---\n\n## Engagement Results\n\n`;
+        output += `---\n\n## Posts Ready for Engagement\n\n`;
+        output += `Below is the full content of each post. Read them carefully, then use ` +
+            `\`comment_on_post\` and \`vote_on_post\` to engage with the ones you find interesting.\n\n`;
         for (const p of posts) {
-            // Read full post
             try {
                 const postRes = await fetch(`${serverUrl}/api/v1/posts/${p.id}`);
                 if (!postRes.ok)
                     continue;
                 const postData = await postRes.json();
                 const fullPost = postData.post;
-                // Decide: upvote if it has technical content
-                const hasTech = /\b(code|function|class|import|const|let|var|def |fn |func |async|await|error|bug|fix|api|database|deploy)\b/i.test(fullPost.content || "");
-                if (hasTech) {
-                    // Upvote
-                    await fetch(`${serverUrl}/api/v1/posts/${p.id}/vote`, {
-                        method: "POST",
-                        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-                        body: JSON.stringify({ value: 1 }),
-                    });
-                    output += `👍 Upvoted: "${p.title}"\n`;
-                }
-                // Comment on posts with 0 comments (be the first!)
                 const commentCount = fullPost.comment_count || fullPost.comments?.length || 0;
-                if (commentCount === 0 && hasTech) {
-                    const topics = (() => {
-                        try {
-                            return JSON.parse(p.tags || "[]");
-                        }
-                        catch {
-                            return [];
-                        }
-                    })();
-                    const commentText = topics.length > 0
-                        ? `Interesting session covering ${topics.slice(0, 3).join(", ")}. The insights shared here are valuable for the community. Would love to see more details on the approach taken!`
-                        : `Great post! The technical details shared here are helpful. Looking forward to more insights from your coding sessions.`;
-                    await fetch(`${serverUrl}/api/v1/posts/${p.id}/comment`, {
-                        method: "POST",
-                        headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
-                        body: JSON.stringify({ content: commentText }),
-                    });
-                    output += `💬 Commented on: "${p.title}"\n`;
-                }
+                output += `---\n\n`;
+                output += `### ${fullPost.title}\n`;
+                output += `- **ID:** \`${p.id}\`\n`;
+                output += `- **Comments:** ${commentCount} | **Views:** ${fullPost.views || 0}\n`;
+                output += `\n${(fullPost.content || "").slice(0, 1500)}\n\n`;
             }
             catch {
                 continue;
             }
         }
-        output += `\n✅ Engagement complete!`;
+        output += `---\n\n`;
+        output += `💡 Now use \`vote_on_post\` and \`comment_on_post\` to engage. ` +
+            `Write genuine, specific comments based on what you read above.\n`;
         return { content: [text(output)] };
     }
     catch (err) {

package/dist/lib/platform.js

@@ -1,3 +1,4 @@
+import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 export function getPlatform() {
@@ -38,7 +39,6 @@ export function getLocalAppDataDir() {
 }
 // Resolve a list of candidate paths, return all that exist
 export function resolvePaths(candidates) {
-    const fs = require("fs");
     return candidates.filter((p) => {
         try {
             return fs.existsSync(p);

package/dist/lib/registry.d.ts

@@ -2,7 +2,7 @@ import type { Scanner, Session, ParsedSession } from "./types.js";
 export declare function registerScanner(scanner: Scanner): void;
 export declare function getScanners(): Scanner[];
 export declare function getScannerBySource(source: string): Scanner | undefined;
-export declare function scanAll(limit?: number): Session[];
+export declare function scanAll(limit?: number, source?: string): Session[];
 export declare function parseSession(filePath: string, source: string, maxTurns?: number): ParsedSession | null;
 export declare function listScannerStatus(): Array<{
     name: string;

package/dist/lib/registry.js

@@ -23,9 +23,11 @@ function safeScannerCall(scannerName, method, fn, fallback) {
     }
 }
 // Scan all registered IDEs, merge and sort results
-export function scanAll(limit = 20) {
+// If source is provided, only scan that specific IDE
+export function scanAll(limit = 20, source) {
     const allSessions = [];
-    for (const scanner of scanners) {
+    const targets = source ? scanners.filter((s) => s.sourceType === source) : scanners;
+    for (const scanner of targets) {
         const sessions = safeScannerCall(scanner.name, "scan", () => scanner.scan(limit), []);
         allSessions.push(...sessions);
     }

package/dist/scanners/aider.js

@@ -58,6 +58,7 @@ export const aiderScanner = {
                 });
             }
         }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
         return sessions.slice(0, limit);
     },
     parse(filePath, maxTurns) {

package/dist/scanners/codex.js

@@ -116,7 +116,7 @@ function extractCodexTurns(lines) {
             continue;
         // Extract text from content array
         const textParts = (p.content || [])
-            .filter((c) => c.text && c.type !== "input_text" || c.type === "input_text")
+            .filter((c) => c.text)
             .map((c) => c.text || "")
             .filter(Boolean);
         const content = textParts.join("\n").trim();

package/dist/scanners/continue-dev.js

@@ -67,6 +67,7 @@ export const continueDevScanner = {
                 });
             }
         }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
         return sessions.slice(0, limit);
     },
     parse(filePath, maxTurns) {

package/dist/scanners/cursor.js

@@ -1,29 +1,97 @@
 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)
+// Run a callback with a shared DB connection, safely closing on completion
+function withDb(dbPath, fn, fallback) {
+    try {
+        const db = new BetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            return fn(db);
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        console.error(`[codemolt] Cursor DB error:`, err instanceof Error ? err.message : err);
+        return fallback;
+    }
+}
+// Safe parameterized query helper
+function safeQueryDb(db, sql, params = []) {
+    try {
+        return db.prepare(sql).all(...params);
+    }
+    catch (err) {
+        console.error(`[codemolt] Cursor query error:`, err instanceof Error ? err.message : err);
+        return [];
+    }
+}
+// Parse vscdb virtual path: "vscdb:<dbPath>|<composerId>"
+// Uses '|' as separator to avoid conflicts with ':' in Windows paths (C:\...)
+const VSCDB_SEP = "|";
+function makeVscdbPath(dbPath, composerId) {
+    return `vscdb:${dbPath}${VSCDB_SEP}${composerId}`;
+}
+function parseVscdbVirtualPath(virtualPath) {
+    const prefix = "vscdb:";
+    if (!virtualPath.startsWith(prefix))
+        return null;
+    const rest = virtualPath.slice(prefix.length);
+    const sepIdx = rest.lastIndexOf(VSCDB_SEP);
+    if (sepIdx <= 0)
+        return null;
+    return { dbPath: rest.slice(0, sepIdx), composerId: rest.slice(sepIdx + 1) };
+}
+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 +102,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 +119,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, "/");
+                    projectPath = decodeDirNameToPath(dirName) || undefined;
                 }
                 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 +150,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 +183,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 +203,71 @@ export const cursorScanner = {
                 }
             }
         }
+        // --- FORMAT 3: globalStorage state.vscdb (newer Cursor) ---
+        // This supplements Formats 1 & 2 — adds any sessions not already found
+        const globalDb = getGlobalStoragePath();
+        if (globalDb) {
+            withDb(globalDb, (db) => {
+                const rows = safeQueryDb(db, "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;
+                        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 = safeQueryDb(db, "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: makeVscdbPath(globalDb, composerId),
+                            modifiedAt: updatedAt,
+                            sizeBytes: row.value.length,
+                        });
+                    }
+                    catch { /* skip malformed entries */ }
+                }
+            }, undefined);
+        }
         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 +281,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 +291,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 +306,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 +342,99 @@ export const cursorScanner = {
         };
     },
 };
+// Parse a session stored in globalStorage state.vscdb (Format 3)
+function parseVscdbSession(virtualPath, maxTurns) {
+    const parsed = parseVscdbVirtualPath(virtualPath);
+    if (!parsed)
+        return null;
+    const { dbPath, composerId } = parsed;
+    return withDb(dbPath, (db) => {
+        // Get composer metadata
+        const metaRows = safeQueryDb(db, "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 — single DB connection reused for all queries
+        const turns = [];
+        for (const header of bubbleHeaders) {
+            if (maxTurns && turns.length >= maxTurns)
+                break;
+            const bubbleRows = safeQueryDb(db, "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) {
+                    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,
+        };
+    }, null);
+}
+// Decode a directory name like "Users-zhaoyifei-my-cool-project" back to a real path.
+// Greedy strategy: try longest segments first, check if path exists on disk.
+function decodeDirNameToPath(dirName) {
+    const stripped = dirName.startsWith("-") ? dirName.slice(1) : dirName;
+    const parts = stripped.split("-");
+    let currentPath = "";
+    let i = 0;
+    while (i < parts.length) {
+        let bestMatch = "";
+        let bestLen = 0;
+        for (let end = parts.length; end > i; end--) {
+            const segment = parts.slice(i, end).join("-");
+            const candidate = currentPath + "/" + segment;
+            try {
+                if (fs.existsSync(candidate)) {
+                    bestMatch = candidate;
+                    bestLen = end - i;
+                    break;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        if (bestLen > 0) {
+            currentPath = bestMatch;
+            i += bestLen;
+        }
+        else {
+            currentPath += "/" + parts[i];
+            i++;
+        }
+    }
+    return currentPath || null;
+}

package/dist/scanners/vscode-copilot.js

@@ -67,6 +67,7 @@ export const vscodeCopilotScanner = {
                 }
             }
         }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
         return sessions.slice(0, limit);
     },
     parse(filePath, maxTurns) {

package/dist/scanners/windsurf.js

@@ -1,5 +1,6 @@
 import * as path from "path";
 import * as fs from "fs";
+import BetterSqlite3 from "better-sqlite3";
 import { getHome, getPlatform } from "../lib/platform.js";
 import { listDirs, safeReadJson, safeStats, extractProjectDescription } from "../lib/fs-utils.js";
 export const windsurfScanner = {
@@ -88,19 +89,32 @@ export const windsurfScanner = {
         if (!chatData)
             return null;
         const stats = safeStats(filePath);
-        // Combine all entries' messages
-        const allTurns = [];
-        for (const entry of Object.values(chatData.entries)) {
+        // Find the specific session entry, or fall back to the first one with messages
+        // filePath is the vscdb path; the session ID was used during scan
+        const entries = Object.entries(chatData.entries);
+        if (entries.length === 0)
+            return null;
+        // Use the first entry with actual messages (most common case: one workspace = one chat)
+        let targetEntry = null;
+        let targetId = path.basename(path.dirname(filePath));
+        for (const [id, entry] of entries) {
             const msgs = extractVscdbMessages(entry);
-            allTurns.push(...msgs);
+            if (msgs.length >= 2) {
+                targetEntry = entry;
+                targetId = id;
+                break;
+            }
         }
+        if (!targetEntry)
+            return null;
+        const allTurns = extractVscdbMessages(targetEntry);
         const turns = maxTurns ? allTurns.slice(0, maxTurns) : allTurns;
         if (turns.length === 0)
             return null;
         const humanMsgs = turns.filter((t) => t.role === "human");
         const aiMsgs = turns.filter((t) => t.role === "assistant");
         return {
-            id: path.basename(path.dirname(filePath)),
+            id: targetId,
             source: "windsurf",
             project: path.basename(path.dirname(filePath)),
             title: humanMsgs[0]?.content.slice(0, 80) || "Windsurf session",
@@ -117,8 +131,7 @@ export const windsurfScanner = {
 };
 function readVscdbChatSessions(dbPath) {
     try {
-        const Database = require("better-sqlite3");
-        const db = new Database(dbPath, { readonly: true });
+        const db = new BetterSqlite3(dbPath, { readonly: true, fileMustExist: true });
         const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'chat.ChatSessionStore.index'").get();
         db.close();
         if (!row?.value)

package/dist/scanners/zed.js

@@ -64,6 +64,7 @@ export const zedScanner = {
                 });
             }
         }
+        sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
         return sessions.slice(0, limit);
     },
     parse(filePath, maxTurns) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemolt-mcp",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "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": {