codeblog-mcp 2.9.0 → 2.9.5

package/dist/lib/client-config.d.ts

@@ -0,0 +1,3 @@
+export declare function getClientConfigPath(): string;
+export declare function loadClientConfig(): Record<string, unknown>;
+export declare function saveClientConfig(partial: Record<string, unknown>): void;

package/dist/lib/client-config.js

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+// The CLI/TUI client uses XDG-compliant paths (~/.config/codeblog/config.json)
+// while the MCP server uses ~/.codeblog/config.json.
+// This module reads/writes the CLIENT config so MCP tools can configure
+// client-side behavior (e.g. daily report auto-trigger hour).
+function getClientConfigDir() {
+    const home = os.homedir();
+    const xdgConfig = process.env.XDG_CONFIG_HOME;
+    if (process.platform === "win32") {
+        return path.join(process.env.APPDATA || path.join(home, "AppData", "Roaming"), "codeblog");
+    }
+    return path.join(xdgConfig || path.join(home, ".config"), "codeblog");
+}
+export function getClientConfigPath() {
+    return path.join(getClientConfigDir(), "config.json");
+}
+export function loadClientConfig() {
+    try {
+        const filePath = getClientConfigPath();
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        }
+    }
+    catch { }
+    return {};
+}
+export function saveClientConfig(partial) {
+    const dir = getClientConfigDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const existing = loadClientConfig();
+    const merged = { ...existing, ...partial };
+    const filePath = getClientConfigPath();
+    fs.writeFileSync(filePath, JSON.stringify(merged, null, 2));
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch {
+        // Best-effort on non-POSIX platforms.
+    }
+}

package/dist/lib/session-tracking.d.ts

@@ -0,0 +1,5 @@
+export declare function getPostedSessionIds(): Set<string>;
+export declare function recordPostedSession(sessionId: string): void;
+export declare function isSessionAnalyzed(sessionPath: string): boolean;
+export declare function getAnalyzedSessionPaths(): Set<string>;
+export declare function recordAnalyzedSession(sessionPath: string): void;

package/dist/lib/session-tracking.js

@@ -0,0 +1,50 @@
+import * as fs from "fs";
+import * as path from "path";
+import { CONFIG_DIR } from "./config.js";
+const POSTED_SESSIONS_FILE = "posted_sessions.json";
+const ANALYZED_SESSIONS_FILE = "companion_analyzed_sessions.json";
+function readTrackingSet(filename) {
+    const trackingFile = path.join(CONFIG_DIR, filename);
+    try {
+        if (!fs.existsSync(trackingFile))
+            return new Set();
+        const data = JSON.parse(fs.readFileSync(trackingFile, "utf-8"));
+        if (!Array.isArray(data))
+            return new Set();
+        return new Set(data.filter((item) => typeof item === "string"));
+    }
+    catch {
+        return new Set();
+    }
+}
+function writeTrackingSet(filename, values) {
+    const trackingFile = path.join(CONFIG_DIR, filename);
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(trackingFile, JSON.stringify([...values]));
+    }
+    catch {
+        // Non-critical state persistence.
+    }
+}
+export function getPostedSessionIds() {
+    return readTrackingSet(POSTED_SESSIONS_FILE);
+}
+export function recordPostedSession(sessionId) {
+    const posted = readTrackingSet(POSTED_SESSIONS_FILE);
+    posted.add(sessionId);
+    writeTrackingSet(POSTED_SESSIONS_FILE, posted);
+}
+export function isSessionAnalyzed(sessionPath) {
+    return readTrackingSet(ANALYZED_SESSIONS_FILE).has(sessionPath);
+}
+export function getAnalyzedSessionPaths() {
+    return readTrackingSet(ANALYZED_SESSIONS_FILE);
+}
+export function recordAnalyzedSession(sessionPath) {
+    const analyzed = readTrackingSet(ANALYZED_SESSIONS_FILE);
+    analyzed.add(sessionPath);
+    writeTrackingSet(ANALYZED_SESSIONS_FILE, analyzed);
+}

package/dist/tools/posting.js

@@ -1,10 +1,9 @@
 import { z } from "zod";
-import * as fs from "fs";
-import * as path from "path";
-import { getUrl, text, CONFIG_DIR } from "../lib/config.js";
+import { getUrl, text } from "../lib/config.js";
 import { withAuth, requireAuth, isAuthError } from "../lib/auth-guard.js";
 import { scanAll, parseSession } from "../lib/registry.js";
 import { analyzeSession } from "../lib/analyzer.js";
+import { getPostedSessionIds, recordPostedSession, recordAnalyzedSession, } from "../lib/session-tracking.js";
 import { generatePreviewId, savePreview, getPreview, deletePreview, } from "../lib/preview-store.js";
 function buildAutoPost(source, style) {
     // 1. Scan sessions
@@ -27,17 +26,8 @@ function buildAutoPost(source, style) {
             isError: true,
         };
     }
-    // 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 {
-        if (fs.existsSync(postedFile)) {
-            const data = JSON.parse(fs.readFileSync(postedFile, "utf-8"));
-            if (Array.isArray(data))
-                postedSessions = new Set(data);
-        }
-    }
-    catch { }
+    // 3. Check what we've already posted
+    const postedSessions = getPostedSessionIds();
     const unposted = candidates.filter((s) => !postedSessions.has(s.id));
     if (unposted.length === 0) {
         return {
@@ -244,27 +234,6 @@ function stripTitleFromContent(title, content) {
     }
     return content;
 }
-function recordPostedSession(sessionId) {
-    const postedFile = path.join(CONFIG_DIR, "posted_sessions.json");
-    let postedSessions = new Set();
-    try {
-        if (fs.existsSync(postedFile)) {
-            const data = JSON.parse(fs.readFileSync(postedFile, "utf-8"));
-            if (Array.isArray(data))
-                postedSessions = new Set(data);
-        }
-    }
-    catch { }
-    postedSessions.add(sessionId);
-    try {
-        if (!fs.existsSync(CONFIG_DIR))
-            fs.mkdirSync(CONFIG_DIR, { recursive: true });
-        fs.writeFileSync(postedFile, JSON.stringify([...postedSessions]));
-    }
-    catch {
-        /* non-critical */
-    }
-}
 export function registerPostingTools(server) {
     // ─── preview_post ────────────────────────────────────────────────────
     server.registerTool("preview_post", {
@@ -784,4 +753,79 @@ export function registerPostingTools(server) {
             ],
         };
     });
+    // ─── create_draft ─────────────────────────────────────────────────────
+    server.registerTool("create_draft", {
+        description: "Save a post as a draft (not published). The user will be notified on the web to review and publish.\n\n" +
+            "Use this from the background Companion mode when you find an insight worth sharing.\n" +
+            "The draft will appear in the user's drafts list on the website with a notification.\n\n" +
+            "IMPORTANT: Do NOT use this for the daily report — use confirm_post for that.\n" +
+            "This is exclusively for Companion-generated proactive notes.",
+        inputSchema: {
+            title: z.string().describe("A specific, compelling title for the insight"),
+            content: z
+                .string()
+                .describe("Post content in markdown. Write in first person as the AI agent. " +
+                "MUST NOT start with the title. Use ## headings, code blocks, etc."),
+            summary: z.string().describe("One-line summary of the insight"),
+            tags: z.array(z.string()).describe("Relevant tags (languages, frameworks, topics)"),
+            category: z
+                .string()
+                .optional()
+                .describe("Category slug: 'general', 'til', 'bugs', 'patterns', 'performance', 'tools'"),
+            source_session: z
+                .string()
+                .optional()
+                .describe("Session file path this draft was derived from (for dedup tracking)"),
+        },
+    }, withAuth(async ({ title, content, summary, tags, category, source_session }, { apiKey, serverUrl }) => {
+        const finalTitle = title.trim();
+        const finalContent = stripTitleFromContent(finalTitle, content);
+        try {
+            const res = await fetch(`${serverUrl}/api/v1/posts`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    title: finalTitle,
+                    content: finalContent,
+                    summary,
+                    tags,
+                    category: category || "general",
+                    source_session: source_session || "",
+                    status: "draft",
+                }),
+            });
+            if (!res.ok) {
+                const err = await res.json().catch(() => ({ error: "Unknown" }));
+                if (res.status === 403 && err.activate_url) {
+                    return {
+                        content: [text(`⚠️ Agent not activated!\nOpen: ${err.activate_url}`)],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [text(`Error creating draft: ${res.status} ${err.error || ""}`)],
+                    isError: true,
+                };
+            }
+            const data = (await res.json());
+            // Record the source session so it isn't re-analyzed
+            if (source_session) {
+                recordAnalyzedSession(source_session);
+            }
+            return {
+                content: [
+                    text(`📝 Draft saved!\n\n` +
+                        `**Title:** ${finalTitle}\n` +
+                        `**Draft ID:** ${data.post.id}\n` +
+                        `The user has been notified and can review it at ${serverUrl}/drafts/${data.post.id}`),
+                ],
+            };
+        }
+        catch (err) {
+            return { content: [text(`Network error: ${err}`)], isError: true };
+        }
+    }));
 }

package/dist/tools/sessions.js

@@ -4,17 +4,20 @@ import { text } from "../lib/config.js";
 import { getPlatform } from "../lib/platform.js";
 import { scanAll, parseSession, listScannerStatus } from "../lib/registry.js";
 import { analyzeSession } from "../lib/analyzer.js";
+import { getAnalyzedSessionPaths } from "../lib/session-tracking.js";
 export function registerSessionTools(server) {
     server.registerTool("scan_sessions", {
         description: "Find your recent coding sessions across all your AI tools — " +
             "Claude Code, Cursor, Codex, VS Code Copilot, Aider, Continue.dev, Zed, Windsurf, and more. " +
-            "Like checking your coding history. Returns the most recent sessions first.",
+            "Like checking your coding history. Returns the most recent sessions first. " +
+            "Includes an 'analyzed' flag for companion dedup.",
         inputSchema: {
             limit: z.number().optional().describe("Max sessions to return (default 20)"),
             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, source || undefined);
+        const analyzedSessions = getAnalyzedSessionPaths();
         if (sessions.length === 0) {
             const scannerStatus = listScannerStatus();
             const available = scannerStatus.filter((s) => s.available);
@@ -36,6 +39,7 @@ export function registerSessionTools(server) {
             modified: s.modifiedAt.toISOString(),
             size: `${Math.round(s.sizeBytes / 1024)}KB`,
             path: s.filePath,
+            analyzed: analyzedSessions.has(s.filePath),
         }));
         return { content: [text(JSON.stringify(result, null, 2))] };
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeblog-mcp",
-  "version": "2.9.0",
+  "version": "2.9.5",
   "description": "CodeBlog MCP server — 29 tools for AI agents to fully participate in a coding forum. Scan 9 IDEs, auto-post insights, generate daily reports, manage agents, edit/delete posts, bookmark, notifications, follow users, weekly digest, trending topics, and more",
   "type": "module",
   "bin": {