@noteplanco/noteplan-mcp 1.1.23 → 1.1.25

package/dist/server.js

@@ -24,9 +24,11 @@ import * as templateTools from './tools/templates.js';
 import * as attachmentTools from './tools/attachments.js';
 import { parseFlexibleDate } from './utils/date-utils.js';
 import { upgradeMessage, getNotePlanVersion, getMcpServerVersion, MIN_BUILD_ADVANCED_FEATURES, MIN_BUILD_CREATE_BACKUP } from './utils/version.js';
-import { isReadOnly, isSkipDryRun } from './utils/server-config.js';
+import { isReadOnly, isSkipDryRun, shouldAutoLaunchNotePlan } from './utils/server-config.js';
 import { initSqlite } from './noteplan/sqlite-loader.js';
 import { getDatabase, getDatabasePath, listSpaces as listSpacesFromDb } from './noteplan/sqlite-reader.js';
+import { getBridgeClient } from './transport/bridge-availability.js';
+import { withBackendTracking, getCurrentBackends } from './transport/bridge-context.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const PLUGIN_API_DOCS_DIR = path.join(__dirname, '../docs/plugin-api');
@@ -236,7 +238,7 @@ const PERIOD_TYPE_MAP = {
     quarter: 'quarterly',
     year: 'yearly',
 };
-function dispatchGetNotes(args) {
+async function dispatchGetNotes(args) {
     const { resolve, resolveQuery, id, title, filename, date, period, count, rangePeriod, startDate, endDate, folder, space, types, query, limit, offset, cursor, minScore, ambiguityDelta, 
     // periodic note params
     week, month, quarter, year, fromDate, includeContent, includeMissing, maxLookback, 
@@ -839,19 +841,35 @@ function withDuration(result, durationMs, includeTiming) {
         durationMs,
     };
 }
-const SERVER_VERSION = '1.1.15';
+/** Attach `backends` (e.g. `["bridge"]` or `["fallback"]` or both) to a tool
+ *  response when the tool's work passed through bridgeOrFallback. Reads the
+ *  request-scoped tracker set up by withBackendTracking in the dispatcher.
+ *  No-op for results that aren't plain objects. */
+function withBackend(result) {
+    const backends = getCurrentBackends();
+    if (backends.length === 0)
+        return result;
+    if (result && typeof result === 'object' && !Array.isArray(result)) {
+        return {
+            ...result,
+            backends,
+        };
+    }
+    return result;
+}
 // Create the server
 export function createServer() {
+    const mcpServerVersion = getMcpServerVersion();
     const server = new Server({
         name: 'NotePlan',
-        version: SERVER_VERSION,
+        version: mcpServerVersion,
     }, {
         capabilities: {
             tools: { listChanged: true },
             resources: {},
         },
         instructions: [
-            `You have access to NotePlan — a markdown-based note-taking and task management app for macOS/iOS. (MCP server v${SERVER_VERSION})`,
+            `You have access to NotePlan — a markdown-based note-taking and task management app for macOS/iOS. (MCP server v${mcpServerVersion})`,
             'All tools use action-based dispatch: one tool per domain, with an `action` parameter to select the operation.',
             '',
             '## Workflow',
@@ -923,8 +941,9 @@ export function createServer() {
         const database = getDatabase();
         const writable = database ? 'read-write' : 'unavailable';
         console.error(`[noteplan-mcp] Space database: ${dbPath} (${writable})`);
-        const spaces = listSpacesFromDb();
-        console.error(`[noteplan-mcp] Spaces discovered: ${spaces.length}`);
+        listSpacesFromDb()
+            .then((spaces) => console.error(`[noteplan-mcp] Spaces discovered: ${spaces.length}`))
+            .catch((err) => console.error('[noteplan-mcp] Failed to list spaces:', err));
     }
     else {
         console.error('[noteplan-mcp] Space database: not found');
@@ -938,6 +957,9 @@ export function createServer() {
     if (skipDryRun) {
         console.error('[noteplan-mcp] Skip dry-run: ENABLED (confirmation tokens not required)');
     }
+    if (!shouldAutoLaunchNotePlan()) {
+        console.error('[noteplan-mcp] Auto-launch: DISABLED (NOTEPLAN_MCP_AUTOLAUNCH=false; bridge probe stays passive when NotePlan is closed)');
+    }
     const toolDefinitions = [
         // ── Consolidated tools (16 — action/param-based dispatch) ──
         {
@@ -2472,7 +2494,7 @@ export function createServer() {
         ],
     };
     // Register tool call handler
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request) => withBackendTracking(async () => {
         const { name, arguments: args } = request.params;
         const normalizedName = normalizeToolName(name);
         const includeTiming = isDebugTimingsEnabled(args);
@@ -2485,7 +2507,8 @@ export function createServer() {
             if (args?.action === 'list_actions' && TOOL_ACTIONS[normalizedName]) {
                 result = { success: true, tool: normalizedName, actions: TOOL_ACTIONS[normalizedName] };
                 const resultWithDuration = withDuration(result, Date.now() - startTime, includeTiming);
-                return { content: [{ type: 'text', text: JSON.stringify(resultWithDuration, null, 2) }] };
+                const finalResult = withBackend(resultWithDuration);
+                return { content: [{ type: 'text', text: JSON.stringify(finalResult, null, 2) }] };
             }
             // ── Read-only mode: reject write actions ──
             if (readOnly) {
@@ -2495,9 +2518,10 @@ export function createServer() {
                     const errorResult = { success: false, error: `Read-only mode is enabled (NOTEPLAN_READ_ONLY=true). Write action "${action}" on ${normalizedName} is not allowed.`, code: 'ERR_READ_ONLY' };
                     const hasOutputSchema = !!toolDefinitions.find(t => t.name === normalizedName)?.outputSchema;
                     const resultWithDuration = withDuration(errorResult, Date.now() - startTime, includeTiming);
+                    const finalResult = withBackend(resultWithDuration);
                     return {
-                        content: [{ type: 'text', text: JSON.stringify(resultWithDuration, null, 2) }],
-                        ...(hasOutputSchema ? { structuredContent: resultWithDuration } : {}),
+                        content: [{ type: 'text', text: JSON.stringify(finalResult, null, 2) }],
+                        ...(hasOutputSchema ? { structuredContent: finalResult } : {}),
                         isError: true,
                     };
                 }
@@ -2505,12 +2529,12 @@ export function createServer() {
             switch (normalizedName) {
                 // ── Primary consolidated tools ──
                 case 'noteplan_get_notes':
-                    result = dispatchGetNotes((args ?? {}));
+                    result = await dispatchGetNotes((args ?? {}));
                     break;
                 case 'noteplan_search': {
                     const searchAction = args?.action;
                     if (searchAction === 'list_tags') {
-                        result = spaceTools.listTags(args);
+                        result = await spaceTools.listTags(args);
                     }
                     else {
                         result = await searchTools.searchNotes(args);
@@ -2526,28 +2550,28 @@ export function createServer() {
                     }
                     switch (action) {
                         case 'create':
-                            result = noteTools.createNote(args);
+                            result = await noteTools.createNote(args);
                             break;
                         case 'update':
-                            result = noteTools.updateNote(args);
+                            result = await noteTools.updateNote(args);
                             break;
                         case 'delete':
-                            result = noteTools.deleteNote(args);
+                            result = await noteTools.deleteNote(args);
                             break;
                         case 'move':
-                            result = noteTools.moveNote(args);
+                            result = await noteTools.moveNote(args);
                             break;
                         case 'restore':
-                            result = noteTools.restoreNote(args);
+                            result = await noteTools.restoreNote(args);
                             break;
                         case 'rename':
-                            result = noteTools.renameNoteFile(args);
+                            result = await noteTools.renameNoteFile(args);
                             break;
                         case 'set_property':
-                            result = noteTools.setProperty(args);
+                            result = await noteTools.setProperty(args);
                             break;
                         case 'remove_property':
-                            result = noteTools.removeProperty(args);
+                            result = await noteTools.removeProperty(args);
                             break;
                         default: throw new Error(`Unknown action: "${action}". Valid actions: create, update, delete, move, restore, rename, set_property, remove_property`);
                     }
@@ -2566,19 +2590,19 @@ export function createServer() {
                     const action = a?.action;
                     switch (action) {
                         case 'insert':
-                            result = noteTools.insertContent(a);
+                            result = await noteTools.insertContent(a);
                             break;
                         case 'append':
-                            result = noteTools.appendContent(a);
+                            result = await noteTools.appendContent(a);
                             break;
                         case 'delete_lines':
-                            result = noteTools.deleteLines(a);
+                            result = await noteTools.deleteLines(a);
                             break;
                         case 'edit_line':
-                            result = noteTools.editLine(a);
+                            result = await noteTools.editLine(a);
                             break;
                         case 'replace_lines':
-                            result = noteTools.replaceLines(a);
+                            result = await noteTools.replaceLines(a);
                             break;
                         default: throw new Error(`Unknown action: "${action}". Valid actions: insert, append, delete_lines, edit_line, replace_lines (snake_case required)`);
                     }
@@ -2601,25 +2625,25 @@ export function createServer() {
                     const action = a?.action;
                     switch (action) {
                         case 'get':
-                            result = noteTools.getParagraphs(a);
+                            result = await noteTools.getParagraphs(a);
                             break;
                         case 'search':
-                            result = noteTools.searchParagraphs(a);
+                            result = await noteTools.searchParagraphs(a);
                             break;
                         case 'search_global':
-                            result = noteTools.searchParagraphsGlobal(a);
+                            result = await noteTools.searchParagraphsGlobal(a);
                             break;
                         case 'add':
-                            result = taskTools.addTaskToNote(a);
+                            result = await taskTools.addTaskToNote(a);
                             break;
                         case 'complete':
-                            result = taskTools.completeTask(a);
+                            result = await taskTools.completeTask(a);
                             break;
                         case 'update':
-                            result = taskTools.updateTask(a);
+                            result = await taskTools.updateTask(a);
                             break;
                         case 'delete_recurring':
-                            result = taskTools.deleteRecurringTask(a);
+                            result = await taskTools.deleteRecurringTask(a);
                             break;
                         default: throw new Error(`Unknown action: ${action}`);
                     }
@@ -2634,28 +2658,28 @@ export function createServer() {
                     }
                     switch (action) {
                         case 'list':
-                            result = spaceTools.listFolders(args);
+                            result = await spaceTools.listFolders(args);
                             break;
                         case 'find':
-                            result = spaceTools.findFolders(args);
+                            result = await spaceTools.findFolders(args);
                             break;
                         case 'resolve':
-                            result = spaceTools.resolveFolder(args);
+                            result = await spaceTools.resolveFolder(args);
                             break;
                         case 'create':
-                            result = spaceTools.createFolder(args);
+                            result = await spaceTools.createFolder(args);
                             break;
                         case 'move':
-                            result = spaceTools.moveFolder(args);
+                            result = await spaceTools.moveFolder(args);
                             break;
                         case 'rename':
-                            result = spaceTools.renameFolder(args);
+                            result = await spaceTools.renameFolder(args);
                             break;
                         case 'delete':
-                            result = spaceTools.deleteFolder(args);
+                            result = await spaceTools.deleteFolder(args);
                             break;
                         case 'list_spaces':
-                            result = spaceTools.listSpaces(args);
+                            result = await spaceTools.listSpaces(args);
                             break;
                         default: throw new Error(`Unknown action: ${action}`);
                     }
@@ -2665,22 +2689,22 @@ export function createServer() {
                     const action = args?.action;
                     switch (action) {
                         case 'list':
-                            result = filterTools.listFilters(args);
+                            result = await filterTools.listFilters(args);
                             break;
                         case 'get':
-                            result = filterTools.getFilter(args);
+                            result = await filterTools.getFilter(args);
                             break;
                         case 'get_tasks':
-                            result = filterTools.getFilterTasks(args);
+                            result = await filterTools.getFilterTasks(args);
                             break;
                         case 'list_parameters':
-                            result = filterTools.listFilterParameters();
+                            result = await filterTools.listFilterParameters();
                             break;
                         case 'save':
-                            result = filterTools.saveFilter(args);
+                            result = await filterTools.saveFilter(args);
                             break;
                         case 'rename':
-                            result = filterTools.renameFilter(args);
+                            result = await filterTools.renameFilter(args);
                             break;
                         default: throw new Error(`Unknown action: ${action}`);
                     }
@@ -2764,7 +2788,7 @@ export function createServer() {
                             result = uiTools.openToday(args);
                             break;
                         case 'search':
-                            result = uiTools.searchNotes(args);
+                            result = await uiTools.searchNotes(args);
                             break;
                         case 'run_plugin':
                             result = uiTools.runPlugin(args);
@@ -2815,7 +2839,7 @@ export function createServer() {
                                         result = uiTools.openToday(args);
                                         break;
                                     case 'search':
-                                        result = uiTools.searchNotes(args);
+                                        result = await uiTools.searchNotes(args);
                                         break;
                                     case 'run_plugin':
                                         result = uiTools.runPlugin(args);
@@ -2943,16 +2967,16 @@ export function createServer() {
                     const action = args?.action;
                     switch (action) {
                         case 'add':
-                            result = attachmentTools.addAttachment(args);
+                            result = await attachmentTools.addAttachment(args);
                             break;
                         case 'list':
-                            result = attachmentTools.listAttachments(args);
+                            result = await attachmentTools.listAttachments(args);
                             break;
                         case 'get':
-                            result = attachmentTools.getAttachment(args);
+                            result = await attachmentTools.getAttachment(args);
                             break;
                         case 'move':
-                            result = attachmentTools.moveAttachment(args);
+                            result = await attachmentTools.moveAttachment(args);
                             break;
                         default: throw new Error(`Unknown action: ${action}. Valid actions: add, list, get, move`);
                     }
@@ -2965,15 +2989,16 @@ export function createServer() {
             const resultWithSuggestions = withSuggestedNextTools(enrichedResult, normalizedName, registeredToolNameSet);
             const resultWithMemory = withMemoryHints(resultWithSuggestions, normalizedName);
             const resultWithDuration = withDuration(resultWithMemory, Date.now() - startTime, includeTiming);
+            const finalResult = withBackend(resultWithDuration);
             // Log non-throwing errors (success: false returned without an exception)
-            if (resultWithDuration && typeof resultWithDuration === 'object' && resultWithDuration.success === false) {
+            if (finalResult && typeof finalResult === 'object' && finalResult.success === false) {
                 const duration = Date.now() - startTime;
-                const errMsg = resultWithDuration.error || 'unknown';
+                const errMsg = finalResult.error || 'unknown';
                 console.error(`[noteplan-mcp] Tool failed: ${actionLabel} (${duration}ms): ${errMsg}`);
             }
             const hasOutputSchema = Boolean(toolDefinitionByName.get(normalizedName)?.outputSchema);
             // If the result contains image data, return it as an MCP image content block
-            const typedResult = resultWithDuration;
+            const typedResult = finalResult;
             if (typedResult._imageData && typedResult._imageMimeType) {
                 const imageData = typedResult._imageData;
                 const imageMimeType = typedResult._imageMimeType;
@@ -2997,10 +3022,10 @@ export function createServer() {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(resultWithDuration),
+                        text: JSON.stringify(finalResult),
                     },
                 ],
-                ...(hasOutputSchema ? { structuredContent: resultWithDuration } : {}),
+                ...(hasOutputSchema ? { structuredContent: finalResult } : {}),
             };
         }
         catch (error) {
@@ -3022,26 +3047,82 @@ export function createServer() {
                 retryable: meta.retryable,
             };
             const errorWithDuration = withDuration(errorResult, Date.now() - startTime, includeTiming);
+            const finalErrorResult = withBackend(errorWithDuration);
             const hasOutputSchema = Boolean(toolDefinitionByName.get(normalizedName)?.outputSchema);
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify(errorWithDuration),
+                        text: JSON.stringify(finalErrorResult),
                     },
                 ],
-                ...(hasOutputSchema ? { structuredContent: errorWithDuration } : {}),
+                ...(hasOutputSchema ? { structuredContent: finalErrorResult } : {}),
                 isError: true,
             };
         }
-    });
+        finally {
+            // Per-call backend summary so support reading the log linearly can tell
+            // whether the call used the HTTP bridge or the SQLite/FS fallback. Mixed
+            // calls (multiple bridge ops where one fell back) show "bridge+fallback".
+            const backends = getCurrentBackends();
+            if (backends.length > 0) {
+                console.error(`[noteplan-mcp]   ↳ backend: ${backends.join('+')}`);
+            }
+        }
+    }));
     return server;
 }
+// Discover the bridge and run one cheap search call so NotePlan's
+// SearchHelper / NoteCache is hot before the first user request lands.
+// Bounded so a hung bridge can't wedge MCP startup. Errors are logged
+// but never fatal: if the bridge is unreachable, the cascade falls
+// through to ripgrep on the first request just like before.
+const BRIDGE_WARMUP_TIMEOUT_MS = 5_000;
+async function probeAndWarmBridge() {
+    const deadline = Date.now() + BRIDGE_WARMUP_TIMEOUT_MS;
+    const remaining = () => Math.max(0, deadline - Date.now());
+    const withTimeout = (promise, label) => new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(`${label} timeout`)), remaining());
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+    try {
+        const client = await withTimeout(getBridgeClient(), 'bridge discover');
+        if (!client) {
+            console.error('[noteplan-mcp] Bridge unavailable (NotePlan not running, old build, or Automation denied)');
+            return;
+        }
+        const config = await withTimeout(client.config(), 'bridge config');
+        console.error(`[noteplan-mcp] Bridge OK on 127.0.0.1:${client.port} — storage: ${config.storagePath}`);
+        try {
+            await withTimeout(client.search('__np_mcp_warmup_no_match__', { limit: 1 }), 'bridge warmup');
+        }
+        catch (err) {
+            // Warm-up is best-effort: a failure here means the first user
+            // search may still take the cold path. Don't escalate — the
+            // cascade in `searchWithRipgrep` already handles bridge errors.
+            console.error(`[noteplan-mcp] Bridge warmup skipped: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    catch (err) {
+        console.error(`[noteplan-mcp] Bridge probe failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 // Start the server with stdio transport
 export async function startServer() {
     console.error(`[noteplan-mcp] Starting v${getMcpServerVersion()} (Node ${process.version}, ${process.platform} ${process.arch}, pid ${process.pid})`);
     await initSqlite();
     const server = createServer();
+    // Bridge probe + SearchHelper / NoteCache warm-up. AWAIT this before
+    // accepting requests so the user's first search hits the warm bridge
+    // instead of racing it and falling back to ripgrep. Bounded by a
+    // short overall timeout so a wedged bridge can't block startup.
+    await probeAndWarmBridge();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('[noteplan-mcp] Server running on stdio');