burn-mcp-server 1.0.1 → 1.2.0

package/dist/index.js

@@ -10,174 +10,474 @@ const zod_1 = require("zod");
 // ---------------------------------------------------------------------------
 const SUPABASE_URL = process.env.BURN_SUPABASE_URL || 'https://juqtxylquemiuvvmgbej.supabase.co';
 const SUPABASE_ANON_KEY = process.env.BURN_SUPABASE_ANON_KEY || 'sb_publishable_reVgmmCC6ndIo6jFRMM2LQ_wujj5FrO';
-const SUPABASE_TOKEN = process.env.BURN_SUPABASE_TOKEN;
-if (!SUPABASE_TOKEN) {
-    console.error('Error: BURN_SUPABASE_TOKEN environment variable is required.');
-    console.error('Get your token from: Burn App → Settings → MCP Server → Copy Access Token');
+// Support both old JWT token (BURN_SUPABASE_TOKEN) and new long-lived MCP token (BURN_MCP_TOKEN)
+const MCP_TOKEN = process.env.BURN_MCP_TOKEN;
+const LEGACY_JWT = process.env.BURN_SUPABASE_TOKEN;
+if (!MCP_TOKEN && !LEGACY_JWT) {
+    console.error('Error: BURN_MCP_TOKEN environment variable is required.');
+    console.error('Get your token from: Burn App → Settings → MCP Server → Generate Token');
     process.exit(1);
 }
 // ---------------------------------------------------------------------------
-// Supabase client (authenticated as user via JWT)
+// Supabase client — bootstrapped with anon key, session set after auth below
 // ---------------------------------------------------------------------------
 const supabase = (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_ANON_KEY, {
     auth: {
         persistSession: false,
-        autoRefreshToken: false,
-    },
-    global: {
-        headers: {
-            Authorization: `Bearer ${SUPABASE_TOKEN}`,
-        },
+        autoRefreshToken: true,
     },
+    ...(LEGACY_JWT ? { global: { headers: { Authorization: `Bearer ${LEGACY_JWT}` } } } : {}),
 });
 // ---------------------------------------------------------------------------
+// Auth: exchange MCP token for a real Supabase session (auto-refreshes)
+// ---------------------------------------------------------------------------
+async function initAuth() {
+    if (LEGACY_JWT)
+        return; // legacy mode: JWT already set in headers above
+    // Call SECURITY DEFINER function — works with anon key, no JWT needed
+    const { data, error } = await supabase.rpc('get_mcp_session', { p_token: MCP_TOKEN });
+    if (error || !data || data.length === 0) {
+        console.error('Error: Invalid or revoked BURN_MCP_TOKEN.');
+        console.error('Generate a new token in Burn App → Settings → MCP Server → Generate Token');
+        process.exit(1);
+    }
+    const { refresh_token } = data[0];
+    const { error: refreshError } = await supabase.auth.refreshSession({ refresh_token });
+    if (refreshError) {
+        console.error('Error: Failed to refresh session with stored token.', refreshError.message);
+        process.exit(1);
+    }
+    // supabase client now has a valid session and will auto-refresh going forward
+}
+// ---------------------------------------------------------------------------
 // MCP Server
 // ---------------------------------------------------------------------------
 const server = new mcp_js_1.McpServer({
     name: 'burn-mcp-server',
-    version: '1.0.0',
+    version: '1.2.0',
 });
 // ---------------------------------------------------------------------------
-// Tool: search_vault
+// Helper: standard text result
 // ---------------------------------------------------------------------------
-server.tool('search_vault', 'Search your Burn Vault for bookmarks by keyword', {
-    query: zod_1.z.string().describe('Search keyword'),
-    limit: zod_1.z.number().optional().default(10).describe('Max results (default 10)'),
-}, async ({ query, limit }) => {
-    const { data, error } = await supabase
-        .from('bookmarks')
-        .select('id, url, title, author, ai_positioning, ai_takeaway, tags, vault_category, vaulted_at')
-        .eq('status', 'vault')
-        .or(`title.ilike.%${query}%,ai_takeaway.cs.{${query}},tags.cs.{${query}}`)
-        .order('vaulted_at', { ascending: false })
-        .limit(limit || 10);
-    if (error) {
-        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
-    }
+function textResult(text) {
+    return { content: [{ type: 'text', text }] };
+}
+// ---------------------------------------------------------------------------
+// Helper: extract fields from content_metadata JSONB
+// ---------------------------------------------------------------------------
+function meta(row) {
+    const m = row.content_metadata || {};
     return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(data, null, 2),
-            }],
+        id: row.id,
+        url: row.url,
+        title: row.title,
+        author: m.author || row.author || null,
+        platform: row.platform,
+        status: row.status,
+        tags: m.tags || [],
+        thumbnail: m.thumbnail || null,
+        vaultCategory: m.vault_category || null,
+        vaultedAt: m.vaulted_at || null,
+        aiPositioning: m.ai_positioning || null,
+        aiDensity: m.ai_density || null,
+        aiMinutes: m.ai_minutes || null,
+        aiTakeaway: m.ai_takeaway || [],
+        aiStrategyReason: m.ai_strategy_reason || null,
+        aiHowToRead: m.ai_how_to_read || null,
+        aiOverlap: m.ai_overlap || null,
+        aiVerdict: m.ai_verdict || null,
+        aiSummary: m.ai_summary || null,
+        sparkInsight: m.spark_insight || null,
+        extractedContent: m.extracted_content || null,
+        externalURL: m.external_url || null,
+        aiRelevance: m.ai_relevance || null,
+        aiNovelty: m.ai_novelty || null,
+        createdAt: row.created_at,
+        countdownExpiresAt: row.countdown_expires_at,
+        readAt: row.read_at,
     };
-});
+}
+/** Compact summary for list views (no extracted content) */
+function metaSummary(row) {
+    const m = row.content_metadata || {};
+    return {
+        id: row.id,
+        url: row.url,
+        title: row.title,
+        author: m.author || null,
+        platform: row.platform,
+        tags: m.tags || [],
+        vaultCategory: m.vault_category || null,
+        vaultedAt: m.vaulted_at || null,
+        aiPositioning: m.ai_positioning || null,
+        aiTakeaway: m.ai_takeaway || [],
+    };
+}
 // ---------------------------------------------------------------------------
-// Tool: get_bookmark
+// Tool handlers
 // ---------------------------------------------------------------------------
-server.tool('get_bookmark', 'Get full details of a single bookmark including AI analysis and content', {
-    id: zod_1.z.string().describe('Bookmark UUID'),
-}, async ({ id }) => {
+async function handleSearchVault(args) {
+    const { query, limit } = args;
     const { data, error } = await supabase
         .from('bookmarks')
         .select('*')
-        .eq('id', id)
-        .single();
-    if (error) {
-        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
+        .eq('status', 'absorbed')
+        .ilike('title', `%${query}%`)
+        .order('created_at', { ascending: false })
+        .limit(limit || 10);
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    // Also search in content_metadata tags and takeaway
+    let results = (data || []).map(metaSummary);
+    // If title search returned few results, also search by tag
+    if (results.length < (limit || 10)) {
+        const { data: tagData } = await supabase
+            .from('bookmarks')
+            .select('*')
+            .eq('status', 'absorbed')
+            .order('created_at', { ascending: false })
+            .limit(50);
+        if (tagData) {
+            const existingIds = new Set(results.map((r) => r.id));
+            const tagMatches = tagData
+                .filter((row) => {
+                if (existingIds.has(row.id))
+                    return false;
+                const m = row.content_metadata || {};
+                const tags = (m.tags || []);
+                const takeaway = (m.ai_takeaway || []);
+                const positioning = m.ai_positioning || '';
+                const allText = [...tags, ...takeaway, positioning].join(' ').toLowerCase();
+                return allText.includes(query.toLowerCase());
+            })
+                .map(metaSummary);
+            results = [...results, ...tagMatches].slice(0, limit || 10);
+        }
     }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(data, null, 2),
-            }],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: list_categories
-// ---------------------------------------------------------------------------
-server.tool('list_categories', 'List all Vault categories with article counts', {}, async () => {
+    return textResult(JSON.stringify(results, null, 2));
+}
+async function handleGetBookmark(args) {
     const { data, error } = await supabase
         .from('bookmarks')
-        .select('vault_category')
-        .eq('status', 'vault');
-    if (error) {
-        return { content: [{ type: 'text', text: `Error: ${error.message}` }] };
-    }
-    // Group by category and count
+        .select('*')
+        .eq('id', args.id)
+        .single();
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    return textResult(JSON.stringify(meta(data), null, 2));
+}
+async function handleListCategories() {
+    const { data, error } = await supabase
+        .from('bookmarks')
+        .select('content_metadata')
+        .eq('status', 'absorbed');
+    if (error)
+        return textResult(`Error: ${error.message}`);
     const counts = {};
     for (const row of data || []) {
-        const cat = row.vault_category || 'Uncategorized';
+        const cat = row.content_metadata?.vault_category || 'Uncategorized';
         counts[cat] = (counts[cat] || 0) + 1;
     }
     const categories = Object.entries(counts)
         .map(([category, count]) => ({ category, count }))
         .sort((a, b) => b.count - a.count);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(categories, null, 2),
-            }],
-    };
-});
-// ---------------------------------------------------------------------------
-// Tool: get_clusters
-// ---------------------------------------------------------------------------
-server.tool('get_clusters', 'Get AI-generated topic clusters from your Vault', {}, async () => {
+    return textResult(JSON.stringify(categories, null, 2));
+}
+async function handleGetCollections() {
     const { data, error } = await supabase
-        .from('vault_clusters')
-        .select('clusters, generated_at, stale')
+        .from('collections')
+        .select('id, name, bookmark_ids, ai_overview');
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    const collections = (data || []).map((c) => ({
+        id: c.id,
+        name: c.name,
+        articleCount: Array.isArray(c.bookmark_ids) ? c.bookmark_ids.length : 0,
+        overview: c.ai_overview?.theme || null,
+    }));
+    return textResult(JSON.stringify(collections, null, 2));
+}
+async function handleGetCollectionOverview(args) {
+    const { data: collection, error } = await supabase
+        .from('collections')
+        .select('*')
+        .eq('name', args.name)
         .single();
     if (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: error.code === 'PGRST116'
-                        ? 'No clusters generated yet. Open the Vault tab in Burn to generate clusters.'
-                        : `Error: ${error.message}`,
-                }],
-        };
+        return textResult(error.code === 'PGRST116'
+            ? `No collection found with name "${args.name}".`
+            : `Error: ${error.message}`);
     }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({
-                    clusters: data.clusters,
-                    generatedAt: data.generated_at,
-                    isStale: data.stale,
-                }, null, 2),
-            }],
-    };
-});
+    let bookmarks = [];
+    if (Array.isArray(collection.bookmark_ids) && collection.bookmark_ids.length > 0) {
+        const { data: bData, error: bError } = await supabase
+            .from('bookmarks')
+            .select('*')
+            .in('id', collection.bookmark_ids);
+        if (!bError && bData) {
+            bookmarks = bData.map(metaSummary);
+        }
+    }
+    return textResult(JSON.stringify({
+        id: collection.id,
+        name: collection.name,
+        articleCount: Array.isArray(collection.bookmark_ids) ? collection.bookmark_ids.length : 0,
+        aiOverview: collection.ai_overview,
+        bookmarks,
+    }, null, 2));
+}
+async function handleGetArticleContent(args) {
+    const { data, error } = await supabase
+        .from('bookmarks')
+        .select('*')
+        .eq('id', args.id)
+        .single();
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    return textResult(JSON.stringify(meta(data), null, 2));
+}
 // ---------------------------------------------------------------------------
-// Tool: get_cluster_digest
+// Vercel API base URL for content fetching
 // ---------------------------------------------------------------------------
-server.tool('get_cluster_digest', 'Get the AI-generated digest (summary, insights, relationships) for a topic cluster', {
-    clusterName: zod_1.z.string().describe('Name of the cluster'),
-}, async ({ clusterName }) => {
+const API_BASE = process.env.BURN_API_URL || 'https://api.burn451.cloud';
+const API_KEY = 'burn451-2026-secret-key';
+/** Detect platform from URL */
+function detectPlatform(url) {
+    if (/x\.com|twitter\.com/i.test(url))
+        return 'x';
+    if (/youtube\.com|youtu\.be/i.test(url))
+        return 'youtube';
+    if (/reddit\.com|redd\.it/i.test(url))
+        return 'reddit';
+    if (/bilibili\.com|b23\.tv/i.test(url))
+        return 'bilibili';
+    if (/open\.spotify\.com/i.test(url))
+        return 'spotify';
+    if (/mp\.weixin\.qq\.com/i.test(url))
+        return 'wechat';
+    if (/xiaohongshu\.com|xhslink\.com/i.test(url))
+        return 'xhs';
+    return 'web';
+}
+/** Fetch content via Vercel API proxy (bypasses GFW for X.com, etc.) */
+async function fetchViaAPI(url, platform) {
+    try {
+        let endpoint;
+        let params;
+        switch (platform) {
+            case 'x':
+                endpoint = `${API_BASE}/api/parse-x`;
+                params = `url=${encodeURIComponent(url)}`;
+                break;
+            case 'reddit':
+                endpoint = `${API_BASE}/api/parse-reddit`;
+                params = `url=${encodeURIComponent(url)}`;
+                break;
+            case 'spotify':
+                endpoint = `${API_BASE}/api/parse-meta`;
+                params = `url=${encodeURIComponent(url)}&_platform=spotify`;
+                break;
+            case 'wechat':
+            case 'xhs':
+                endpoint = `${API_BASE}/api/parse-meta`;
+                params = `url=${encodeURIComponent(url)}&_platform=${platform}`;
+                break;
+            case 'youtube':
+                // Try transcript extraction via jina-extract with youtube platform hint
+                endpoint = `${API_BASE}/api/jina-extract`;
+                params = `url=${encodeURIComponent(url)}&_platform=youtube`;
+                break;
+            default:
+                endpoint = `${API_BASE}/api/jina-extract`;
+                params = `url=${encodeURIComponent(url)}`;
+                break;
+        }
+        const resp = await fetch(`${endpoint}?${params}`, {
+            headers: {
+                'x-api-key': API_KEY,
+                'Accept': 'application/json',
+            },
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!resp.ok) {
+            return { error: `API returned ${resp.status}` };
+        }
+        const data = await resp.json();
+        // Normalize response across different API endpoints
+        if (platform === 'x') {
+            const text = data.text || data.article_text || '';
+            const quoteText = data.quote ? `\n\n[Quote from @${data.quote.handle}]: ${data.quote.text}` : '';
+            return {
+                title: data.text?.slice(0, 100) || 'Tweet',
+                author: data.author ? `@${data.handle || data.author}` : undefined,
+                content: text + quoteText,
+            };
+        }
+        if (platform === 'spotify') {
+            return {
+                title: data.title,
+                author: data.author,
+                content: data.extracted_content || data.description || null,
+            };
+        }
+        if (platform === 'wechat') {
+            // WeChat parse-meta returns extracted_content from js_content div
+            return {
+                title: data.title,
+                author: data.author,
+                content: data.extracted_content || data.content || null,
+            };
+        }
+        return {
+            title: data.title,
+            author: data.author,
+            content: data.content || data.extracted_content || data.text || data.transcript || null,
+        };
+    }
+    catch (err) {
+        return { error: err.message || 'Fetch failed' };
+    }
+}
+async function handleFetchContent(args) {
+    const { url } = args;
+    const platform = detectPlatform(url);
+    // Step 1: Check if we already have content in Supabase
+    const { data: existing } = await supabase
+        .from('bookmarks')
+        .select('*')
+        .eq('url', url)
+        .limit(1)
+        .maybeSingle();
+    if (existing) {
+        const m = existing.content_metadata || {};
+        if (m.extracted_content && m.extracted_content.length > 50) {
+            return textResult(JSON.stringify({
+                source: 'cache',
+                url,
+                platform,
+                title: existing.title,
+                author: m.author,
+                content: m.extracted_content,
+                aiPositioning: m.ai_positioning,
+                aiTakeaway: m.ai_takeaway,
+                tags: m.tags,
+            }, null, 2));
+        }
+    }
+    // Step 2: Fetch fresh content via Vercel API
+    const result = await fetchViaAPI(url, platform);
+    if (result.error) {
+        return textResult(JSON.stringify({
+            source: 'error',
+            url,
+            platform,
+            error: result.error,
+            hint: platform === 'x' ? 'X.com content is fetched via Vercel Edge proxy to bypass GFW' : undefined,
+        }, null, 2));
+    }
+    return textResult(JSON.stringify({
+        source: 'live',
+        url,
+        platform,
+        title: result.title,
+        author: result.author,
+        content: result.content,
+    }, null, 2));
+}
+async function handleListSparks(args) {
     const { data, error } = await supabase
-        .from('cluster_digests')
-        .select('digest, generated_at')
-        .eq('cluster_name', clusterName)
-        .single();
-    if (error) {
+        .from('bookmarks')
+        .select('*')
+        .eq('status', 'read')
+        .order('created_at', { ascending: false })
+        .limit(args.limit || 20);
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    const results = (data || []).map((row) => {
+        const s = metaSummary(row);
+        const m = row.content_metadata || {};
+        return {
+            ...s,
+            sparkInsight: m.spark_insight || null,
+            sparkExpiresAt: m.spark_expires_at || null,
+        };
+    });
+    return textResult(JSON.stringify(results, null, 2));
+}
+async function handleSearchSparks(args) {
+    const { query, limit } = args;
+    const { data, error } = await supabase
+        .from('bookmarks')
+        .select('*')
+        .eq('status', 'read')
+        .order('created_at', { ascending: false })
+        .limit(50);
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    const results = (data || [])
+        .filter((row) => {
+        const m = row.content_metadata || {};
+        const searchable = [
+            row.title || '',
+            ...(m.tags || []),
+            ...(m.ai_takeaway || []),
+            m.ai_positioning || '',
+            m.spark_insight || '',
+        ].join(' ').toLowerCase();
+        return searchable.includes(query.toLowerCase());
+    })
+        .slice(0, limit || 10)
+        .map((row) => {
+        const s = metaSummary(row);
+        const m = row.content_metadata || {};
         return {
-            content: [{
-                    type: 'text',
-                    text: error.code === 'PGRST116'
-                        ? `No digest found for cluster "${clusterName}". Open the cluster in Burn App to generate a digest first.`
-                        : `Error: ${error.message}`,
-                }],
+            ...s,
+            sparkInsight: m.spark_insight || null,
+            sparkExpiresAt: m.spark_expires_at || null,
         };
+    });
+    return textResult(JSON.stringify(results, null, 2));
+}
+async function handleListVault(args) {
+    let query = supabase
+        .from('bookmarks')
+        .select('*')
+        .eq('status', 'absorbed')
+        .order('created_at', { ascending: false })
+        .limit(args.limit || 20);
+    const { data, error } = await query;
+    if (error)
+        return textResult(`Error: ${error.message}`);
+    let results = (data || []).map(metaSummary);
+    // Filter by category if provided
+    if (args.category) {
+        results = results.filter((r) => r.vaultCategory?.toLowerCase() === args.category.toLowerCase());
     }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({
-                    ...data.digest,
-                    generatedAt: data.generated_at,
-                }, null, 2),
-            }],
-    };
-});
+    return textResult(JSON.stringify(results, null, 2));
+}
+// ---------------------------------------------------------------------------
+// Register tools
+// ---------------------------------------------------------------------------
+// @ts-expect-error — MCP SDK 1.27 TS2589: type instantiation too deep with multiple .tool() calls
+server.tool('search_vault', 'Search your Burn Vault for bookmarks by keyword (searches title, tags, AI takeaway)', { query: zod_1.z.string().describe('Search keyword'), limit: zod_1.z.number().optional().describe('Max results (default 10)') }, handleSearchVault);
+server.tool('list_vault', 'List bookmarks in your Vault, optionally filtered by category', { limit: zod_1.z.number().optional().describe('Max results (default 20)'), category: zod_1.z.string().optional().describe('Filter by vault category') }, handleListVault);
+server.tool('list_sparks', 'List your Sparks (bookmarks you have read, with 30-day lifespan). Includes spark insight and expiry date.', { limit: zod_1.z.number().optional().describe('Max results (default 20)') }, handleListSparks);
+server.tool('search_sparks', 'Search your Sparks by keyword (searches title, tags, AI takeaway, spark insight)', { query: zod_1.z.string().describe('Search keyword'), limit: zod_1.z.number().optional().describe('Max results (default 10)') }, handleSearchSparks);
+server.tool('get_bookmark', 'Get full details of a single bookmark including AI analysis and extracted content', { id: zod_1.z.string().describe('Bookmark UUID') }, handleGetBookmark);
+server.tool('get_article_content', 'Get full article content and AI analysis for a bookmark by ID (same as get_bookmark)', { id: zod_1.z.string().describe('Bookmark UUID') }, handleGetArticleContent);
+server.tool('fetch_content', 'Fetch article/tweet content from a URL. Works with X.com (bypasses GFW via proxy), Reddit, YouTube, Bilibili, WeChat, and any web page. First checks Supabase cache, then fetches live.', { url: zod_1.z.string().describe('The URL to fetch content from') }, handleFetchContent);
+server.tool('list_categories', 'List all Vault categories with article counts', {}, handleListCategories);
+server.tool('get_collections', 'List all your Collections with article counts and AI overview themes', {}, handleGetCollections);
+server.tool('get_collection_overview', 'Get a Collection by name with its AI overview and linked bookmarks metadata', { name: zod_1.z.string().describe('Collection name') }, handleGetCollectionOverview);
 // ---------------------------------------------------------------------------
 // Resource: burn://vault/bookmarks
 // ---------------------------------------------------------------------------
 server.resource('vault-bookmarks', 'burn://vault/bookmarks', async (uri) => {
     const { data, error } = await supabase
         .from('bookmarks')
-        .select('id, url, title, author, ai_positioning, tags, vault_category, vaulted_at')
-        .eq('status', 'vault')
-        .order('vaulted_at', { ascending: false });
+        .select('*')
+        .eq('status', 'absorbed')
+        .order('created_at', { ascending: false });
     if (error) {
         return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify({ error: error.message }) }] };
     }
@@ -185,7 +485,7 @@ server.resource('vault-bookmarks', 'burn://vault/bookmarks', async (uri) => {
         contents: [{
                 uri: uri.href,
                 mimeType: 'application/json',
-                text: JSON.stringify(data, null, 2),
+                text: JSON.stringify((data || []).map(metaSummary), null, 2),
             }],
     };
 });
@@ -195,14 +495,14 @@ server.resource('vault-bookmarks', 'burn://vault/bookmarks', async (uri) => {
 server.resource('vault-categories', 'burn://vault/categories', async (uri) => {
     const { data, error } = await supabase
         .from('bookmarks')
-        .select('vault_category')
-        .eq('status', 'vault');
+        .select('content_metadata')
+        .eq('status', 'absorbed');
     if (error) {
         return { contents: [{ uri: uri.href, mimeType: 'application/json', text: JSON.stringify({ error: error.message }) }] };
     }
     const counts = {};
     for (const row of data || []) {
-        const cat = row.vault_category || 'Uncategorized';
+        const cat = row.content_metadata?.vault_category || 'Uncategorized';
         counts[cat] = (counts[cat] || 0) + 1;
     }
     return {
@@ -217,6 +517,7 @@ server.resource('vault-categories', 'burn://vault/categories', async (uri) => {
 // Start
 // ---------------------------------------------------------------------------
 async function main() {
+    await initAuth();
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
     console.error('Burn MCP Server running on stdio');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "burn-mcp-server",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "MCP Server for Burn — access your Vault from Claude/Cursor",
   "main": "dist/index.js",
   "bin": {