@neverprepared/mcp-markdown-to-confluence 1.4.0 → 1.4.2

package/dist/index.js

@@ -4,8 +4,8 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextpro
 import { z } from 'zod';
 import { ConfluenceClient } from 'confluence.js';
 import matter from 'gray-matter';
-import { readFile, readdir } from 'fs/promises';
-import { join, extname, basename, relative } from 'path';
+import { readFile, readdir, realpath } from 'fs/promises';
+import { join, extname, basename, relative, isAbsolute } from 'path';
 // Deep imports to avoid loading adaptors/filesystem.js which has broken CJS named exports.
 // Pin @markdown-confluence/lib version if these paths change.
 import { parseMarkdownToADF } from '@markdown-confluence/lib/dist/MdToADF.js';
@@ -16,11 +16,18 @@ import { KrokiClient, KrokiMermaidRenderer, KrokiDiagramPlugin } from './kroki/i
 // ---------------------------------------------------------------------------
 // Environment
 // ---------------------------------------------------------------------------
-const CONFLUENCE_BASE_URL = process.env.CONFLUENCE_BASE_URL ?? '';
+const CONFLUENCE_BASE_URL = (process.env.CONFLUENCE_URL ?? '')
+    .replace(/\/wiki\/?$/, '');
 const CONFLUENCE_USERNAME = process.env.CONFLUENCE_USERNAME ?? '';
 const CONFLUENCE_API_TOKEN = process.env.CONFLUENCE_API_TOKEN ?? '';
 const KROKI_URL = process.env.KROKI_URL ?? 'http://localhost:8371';
 // ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const ADF_CONTENT_TYPE = 'atlas_doc_format';
+const DEFAULT_PUBLISH_CONCURRENCY = 5;
+const MAX_PUBLISH_CONCURRENCY = 20;
+// ---------------------------------------------------------------------------
 // Kroki client
 // ---------------------------------------------------------------------------
 const krokiClient = new KrokiClient(KROKI_URL);
@@ -61,8 +68,18 @@ const confluenceClient = new ConfluenceClient({
     },
 });
 // ---------------------------------------------------------------------------
-// Stub LoaderAdaptor — only uploadBuffer is called by the mermaid plugin
+// Helpers
+// ---------------------------------------------------------------------------
+/** Extracts a readable message from an unknown thrown value. */
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 // ---------------------------------------------------------------------------
+// Stub LoaderAdaptor
+// ---------------------------------------------------------------------------
+// The LoaderAdaptor interface requires all methods below, but in MCP context
+// only uploadBuffer is ever invoked (by the diagram pipeline). The remaining
+// methods are stubs required for type compatibility.
 const stubAdaptor = {
     readFile: async (_filePath) => undefined,
     readBinary: async (_filePath) => false,
@@ -70,9 +87,15 @@ const stubAdaptor = {
     listFiles: async () => [],
     uploadBuffer: async (_buffer, _fileName, _mimeType) => undefined,
 };
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+/**
+ * Lightweight diagram count over raw markdown — scans for fenced code block
+ * openings matching a supported diagram type. Used during preview mode to avoid
+ * a full ADF parse just to display a diagram count.
+ */
+const DIAGRAM_FENCE_TYPES = SUPPORTED_DIAGRAM_TYPES.join('|');
+function countDiagramsInMarkdown(markdown) {
+    return (markdown.match(new RegExp(`^\`\`\`(?:${DIAGRAM_FENCE_TYPES})[ \\t]*$`, 'gm')) ?? []).length;
+}
 function countDiagramBlocks(adf) {
     if (typeof adf !== 'object' || adf === null)
         return 0;
@@ -115,6 +138,23 @@ function pLimit(concurrency) {
         next();
     });
 }
+/**
+ * Validates that a user-supplied path is safe to access.
+ * - Must be absolute (prevents relative traversal)
+ * - Must not contain ".." segments (belt-and-suspenders before realpath)
+ * - Resolves symlinks and normalizes via realpath (the canonical defense)
+ * Returns the canonicalized path, or throws if the path is invalid.
+ */
+async function validatePath(inputPath) {
+    if (!isAbsolute(inputPath)) {
+        throw new Error(`Path must be absolute: "${inputPath}"`);
+    }
+    if (inputPath.includes('..')) {
+        throw new Error(`Path must not contain ".." segments: "${inputPath}"`);
+    }
+    // realpath resolves symlinks and normalizes — throws ENOENT if path doesn't exist
+    return realpath(inputPath);
+}
 async function parseMarkdownFile(filePath, overrides) {
     const raw = await readFile(filePath, 'utf-8');
     const parsed = matter(raw);
@@ -136,20 +176,26 @@ async function scanDirectoryTree(rootPath, spaceKey, currentPath = rootPath, dep
     const nodes = [];
     const skipped = [];
     const relFromRoot = relative(rootPath, currentPath) || '.';
-    const parentRel = depth === 0 ? null : (relative(rootPath, join(currentPath, '..')) || '.');
+    // Derive parent path from relFromRoot instead of calling join+relative again.
+    const parentRel = depth === 0 ? null : (relFromRoot.includes('/') ? relFromRoot.substring(0, relFromRoot.lastIndexOf('/')) : '.');
     // Collect subdirectories and markdown files
     const subdirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith('.'));
     const mdFiles = entries.filter((e) => e.isFile() && extname(e.name).toLowerCase() === '.md' && !e.name.startsWith('.'));
     // Check for markdown files that correspond to subdirectories (e.g., "01 - Strategic.md" + "01 - Strategic/")
     const subdirNames = new Set(subdirs.map((d) => d.name));
-    const dirMdFiles = new Set();
+    // Cache parsed results for dir-matching .md files so we don't read them twice.
+    const parsedDirMd = new Map();
     // Process markdown files
     for (const entry of mdFiles) {
         const filePath = join(currentPath, entry.name);
         const stem = basename(entry.name, extname(entry.name));
-        // If this .md file has a matching subdirectory, it will be used as the directory's content
+        // If this .md file has a matching subdirectory, parse and cache it now so
+        // the subdir loop below can reuse the result without a second disk read.
         if (subdirNames.has(stem)) {
-            dirMdFiles.add(stem);
+            const result = await parseMarkdownFile(filePath, { spaceKey, titleFallback: stem });
+            if (!('skipped' in result)) {
+                parsedDirMd.set(stem, result);
+            }
             continue; // handled when processing the subdirectory
         }
         const result = await parseMarkdownFile(filePath, {
@@ -174,18 +220,8 @@ async function scanDirectoryTree(rootPath, spaceKey, currentPath = rootPath, dep
     for (const dir of subdirs) {
         const dirPath = join(currentPath, dir.name);
         const dirRelPath = relative(rootPath, dirPath);
-        // Check for a matching .md file to use as directory content
-        const matchingMdPath = join(currentPath, dir.name + '.md');
-        let dirMarkdownFile;
-        if (dirMdFiles.has(dir.name)) {
-            const result = await parseMarkdownFile(matchingMdPath, {
-                spaceKey,
-                titleFallback: dir.name,
-            });
-            if (!('skipped' in result)) {
-                dirMarkdownFile = result;
-            }
-        }
+        // Reuse the cached parse result from the first loop (avoids a second disk read).
+        const dirMarkdownFile = parsedDirMd.get(dir.name);
         nodes.push({
             relativePath: dirRelPath,
             title: dirMarkdownFile?.title ?? dir.name,
@@ -205,12 +241,15 @@ async function scanDirectoryTree(rootPath, spaceKey, currentPath = rootPath, dep
 // Wiki link resolution
 // ---------------------------------------------------------------------------
 // Matches [[Page Name]] and [[Page Name#Heading]] and [[Page Name|Display Text]]
-const WIKI_LINK_RE = /\[\[([^\]|#]+)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/g;
+// Two separate regex instances: WIKI_LINK_RE_TEST (no /g) is stateless and safe for .test();
+// WIKI_LINK_RE_REPLACE (with /g) is used only by String.replace() which resets lastIndex itself.
+const WIKI_LINK_RE_TEST = /\[\[([^\]|#]+)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/;
+const WIKI_LINK_RE_REPLACE = /\[\[([^\]|#]+)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/g;
 function hasWikiLinks(markdown) {
-    return WIKI_LINK_RE.test(markdown);
+    return WIKI_LINK_RE_TEST.test(markdown);
 }
 function resolveWikiLinks(markdown, titleToUrl) {
-    return markdown.replace(WIKI_LINK_RE, (_match, pageName, heading, displayText) => {
+    return markdown.replace(WIKI_LINK_RE_REPLACE, (_match, pageName, heading, displayText) => {
         const trimmedName = pageName.trim();
         const url = titleToUrl.get(trimmedName);
         if (!url) {
@@ -228,8 +267,55 @@ function resolveWikiLinks(markdown, titleToUrl) {
 // ---------------------------------------------------------------------------
 // Core publish logic
 // ---------------------------------------------------------------------------
+/**
+ * Fetches the current version of an existing page, or creates a blank placeholder
+ * page and returns its new ID and version. Extracted from publishMarkdown to keep
+ * that function focused on the ADF pipeline.
+ */
+async function getOrCreatePage(pageId, spaceKey, title, parentId) {
+    if (pageId) {
+        const existingPage = await confluenceClient.content.getContentById({
+            id: pageId,
+            expand: ['version'],
+        });
+        const version = existingPage.version?.number;
+        if (version === undefined) {
+            throw new Error(`Could not read version for page ${pageId} — Confluence returned no version info`);
+        }
+        return { resolvedPageId: pageId, currentVersion: version };
+    }
+    // No existing page — create a blank placeholder to obtain a pageId, then
+    // update it with the real content in the caller.
+    const blankAdf = { version: 1, type: 'doc', content: [] };
+    const createParams = {
+        space: { key: spaceKey },
+        title,
+        type: 'page',
+        body: {
+            [ADF_CONTENT_TYPE]: {
+                value: JSON.stringify(blankAdf),
+                representation: ADF_CONTENT_TYPE,
+            },
+        },
+    };
+    if (parentId) {
+        createParams.ancestors = [{ id: parentId }];
+    }
+    const created = await confluenceClient.content.createContent(createParams);
+    const resolvedPageId = created.id;
+    const currentVersion = created.version?.number;
+    if (!resolvedPageId || currentVersion === undefined) {
+        throw new Error('Failed to create page: Confluence response is missing id or version');
+    }
+    return { resolvedPageId, currentVersion };
+}
+// Session-level cache: avoids re-fetching attachments for the same page during
+// the wiki-link second-pass (where publishMarkdown is called again for pages
+// that were already published in the first pass).
+const attachmentCache = new Map();
 async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skipPreview = false) {
-    // Parse markdown → ADF
+    // Parse markdown → ADF. Cast once here; downstream library calls accept any.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const adf = parseMarkdownToADF(markdown, CONFLUENCE_BASE_URL);
     const diagramCount = countDiagramBlocks(adf);
     if (!skipPreview) {
@@ -237,59 +323,33 @@ async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skip
         return { isPreview: true, previewText, diagramCount };
     }
     // ----- Full publish -----
-    let currentVersion = 1;
-    let resolvedPageId = pageId;
-    if (resolvedPageId) {
-        // Fetch existing page to get current version
-        const existingPage = await confluenceClient.content.getContentById({
-            id: resolvedPageId,
-            expand: ['version'],
-        });
-        currentVersion = existingPage.version.number;
+    const { resolvedPageId, currentVersion } = await getOrCreatePage(pageId, spaceKey, title, parentId);
+    // Fetch current attachments to build the map (cached per page per session)
+    let currentAttachments;
+    if (attachmentCache.has(resolvedPageId)) {
+        currentAttachments = attachmentCache.get(resolvedPageId);
     }
     else {
-        // Create a placeholder page to obtain a pageId
-        const blankAdf = {
-            version: 1,
-            type: 'doc',
-            content: [],
-        };
-        const createParams = {
-            space: { key: spaceKey },
-            title,
-            type: 'page',
-            body: {
-                atlas_doc_format: {
-                    value: JSON.stringify(blankAdf),
-                    representation: 'atlas_doc_format',
-                },
-            },
-        };
-        if (parentId) {
-            createParams.ancestors = [{ id: parentId }];
-        }
-        const created = await confluenceClient.content.createContent(createParams);
-        resolvedPageId = created.id;
-        currentVersion = created.version.number;
-    }
-    // Fetch current attachments to build the map
-    const attachmentsResult = await confluenceClient.contentAttachments.getAttachments({
-        id: resolvedPageId,
-    });
-    const currentAttachments = {};
-    for (const att of attachmentsResult.results ?? []) {
-        const attTitle = att.title ?? '';
-        const fileId = att.extensions?.fileId ?? '';
-        const collectionName = att.extensions?.collectionName ?? '';
-        if (attTitle) {
-            currentAttachments[attTitle] = {
-                filehash: att.metadata?.comment ?? '',
-                attachmentId: fileId,
-                collectionName,
-            };
+        const attachmentsResult = await confluenceClient.contentAttachments.getAttachments({
+            id: resolvedPageId,
+        });
+        currentAttachments = {};
+        for (const att of attachmentsResult.results ?? []) {
+            const attTitle = att.title ?? '';
+            const fileId = att.extensions?.fileId ?? '';
+            const collectionName = att.extensions?.collectionName ?? '';
+            if (attTitle) {
+                currentAttachments[attTitle] = {
+                    filehash: att.metadata?.comment ?? '',
+                    attachmentId: fileId,
+                    collectionName,
+                };
+            }
         }
+        attachmentCache.set(resolvedPageId, currentAttachments);
     }
     // Build publisher functions
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const publisherFunctions = createPublisherFunctions(confluenceClient, stubAdaptor, resolvedPageId, title, currentAttachments);
     // Run ADF processing pipeline (renders diagrams via Kroki)
     const finalAdf = await executeADFProcessingPipeline([
@@ -303,9 +363,9 @@ async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skip
         type: 'page',
         version: { number: currentVersion + 1 },
         body: {
-            atlas_doc_format: {
+            [ADF_CONTENT_TYPE]: {
                 value: JSON.stringify(finalAdf),
-                representation: 'atlas_doc_format',
+                representation: ADF_CONTENT_TYPE,
             },
         },
     };
@@ -323,6 +383,54 @@ async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skip
     };
 }
 // ---------------------------------------------------------------------------
+// Directory publish helpers
+// ---------------------------------------------------------------------------
+/**
+ * Builds the preview text for a directory publish operation — the tree
+ * visualization shown to the user before they confirm with skip_preview: true.
+ * Extracted from the tool handler to keep it focused on orchestration.
+ */
+function buildDirectoryPreview(nodes, skipped, directoryPath, rootPageId, spaceKey) {
+    const rootTitle = rootPageId
+        ? `(existing page: ${rootPageId})`
+        : `"${basename(directoryPath)}" (will be created)`;
+    const lines = [
+        `=== DIRECTORY TREE PREVIEW ===`,
+        `Directory: ${directoryPath}`,
+        `Space: ${spaceKey}`,
+        `Root page: ${rootTitle}`,
+        `Total pages: ${nodes.length + (rootPageId ? 0 : 1)}`,
+        '',
+        '--- Page tree ---',
+    ];
+    const maxDepth = nodes.reduce((max, n) => Math.max(max, n.depth), 0);
+    for (let d = 0; d <= maxDepth; d++) {
+        for (const node of nodes.filter((n) => n.depth === d)) {
+            const indent = '  '.repeat(d + 1);
+            const suffix = node.isDirectory ? '/' : '';
+            const pageInfo = node.markdownFile?.pageId
+                ? `update: ${node.markdownFile.pageId}`
+                : 'new page';
+            let diagrams = '';
+            if (node.markdownFile) {
+                const count = countDiagramsInMarkdown(node.markdownFile.content);
+                if (count > 0)
+                    diagrams = `, ${count} diagram(s)`;
+            }
+            const label = node.isDirectory && !node.markdownFile ? 'placeholder' : pageInfo;
+            lines.push(`${indent}${node.title}${suffix} (${label}${diagrams})`);
+        }
+    }
+    if (skipped.length > 0) {
+        lines.push('', '--- Skipped files ---');
+        for (const s of skipped) {
+            lines.push(`  ${basename(s.filePath)}: ${s.reason}`);
+        }
+    }
+    lines.push('', `Call again with skip_preview: true to publish.`);
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
 // MCP Server
 // ---------------------------------------------------------------------------
 const server = new Server({ name: 'mcp-markdown-to-confluence', version: '1.0.0' }, { capabilities: { tools: {} } });
@@ -427,6 +535,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const input = z
                 .object({ markdown: z.string(), title: z.string() })
                 .parse(args);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const adf = parseMarkdownToADF(input.markdown, CONFLUENCE_BASE_URL);
             const diagramCount = countDiagramBlocks(adf);
             const previewText = renderADFDoc(adf);
@@ -479,7 +588,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 skip_preview: z.boolean().default(false),
             })
                 .parse(args);
-            const raw = await readFile(input.filePath, 'utf-8');
+            const safeFilePath = await validatePath(input.filePath);
+            const raw = await readFile(safeFilePath, 'utf-8');
             const parsed = matter(raw);
             const title = parsed.data['connie-title'] ?? parsed.data['title'] ?? '';
             const spaceKey = parsed.data['connie-space-key'] ?? '';
@@ -544,11 +654,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 spaceKey: z.string(),
                 rootPageId: z.string().optional(),
                 skip_preview: z.boolean().default(false),
-                concurrency: z.number().int().min(1).max(20).default(5),
+                concurrency: z.number().int().min(1).max(MAX_PUBLISH_CONCURRENCY).default(DEFAULT_PUBLISH_CONCURRENCY),
             })
                 .parse(args);
+            const safeDirectoryPath = await validatePath(input.directoryPath);
             // Scan directory tree
-            const { nodes, skipped } = await scanDirectoryTree(input.directoryPath, input.spaceKey);
+            const { nodes, skipped } = await scanDirectoryTree(safeDirectoryPath, input.spaceKey);
             if (nodes.length === 0 && skipped.length === 0) {
                 return {
                     content: [{ type: 'text', text: `No files found in ${input.directoryPath}` }],
@@ -556,46 +667,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             // Preview mode
             if (!input.skip_preview) {
-                const rootTitle = input.rootPageId
-                    ? `(existing page: ${input.rootPageId})`
-                    : `"${basename(input.directoryPath)}" (will be created)`;
-                const lines = [
-                    `=== DIRECTORY TREE PREVIEW ===`,
-                    `Directory: ${input.directoryPath}`,
-                    `Space: ${input.spaceKey}`,
-                    `Root page: ${rootTitle}`,
-                    `Total pages: ${nodes.length + (input.rootPageId ? 0 : 1)}`,
-                    '',
-                    '--- Page tree ---',
-                ];
-                // Build tree visualization
-                const maxDepth = nodes.reduce((max, n) => Math.max(max, n.depth), 0);
-                for (let d = 0; d <= maxDepth; d++) {
-                    for (const node of nodes.filter((n) => n.depth === d)) {
-                        const indent = '  '.repeat(d + 1);
-                        const suffix = node.isDirectory ? '/' : '';
-                        const pageInfo = node.markdownFile?.pageId
-                            ? `update: ${node.markdownFile.pageId}`
-                            : 'new page';
-                        let diagrams = '';
-                        if (node.markdownFile) {
-                            const adf = parseMarkdownToADF(node.markdownFile.content, CONFLUENCE_BASE_URL);
-                            const count = countDiagramBlocks(adf);
-                            if (count > 0)
-                                diagrams = `, ${count} diagram(s)`;
-                        }
-                        const label = node.isDirectory && !node.markdownFile ? 'placeholder' : pageInfo;
-                        lines.push(`${indent}${node.title}${suffix} (${label}${diagrams})`);
-                    }
-                }
-                if (skipped.length > 0) {
-                    lines.push('', '--- Skipped files ---');
-                    for (const s of skipped) {
-                        lines.push(`  ${basename(s.filePath)}: ${s.reason}`);
-                    }
-                }
-                lines.push('', `Call again with skip_preview: true to publish.`);
-                return { content: [{ type: 'text', text: lines.join('\n') }] };
+                const preview = buildDirectoryPreview(nodes, skipped, input.directoryPath, input.rootPageId, input.spaceKey);
+                return { content: [{ type: 'text', text: preview }] };
             }
             // Publish mode — process level by level
             const limit = pLimit(input.concurrency);
@@ -619,15 +692,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 catch (err) {
                     return {
                         isError: true,
-                        content: [{
-                                type: 'text',
-                                text: `Error creating root page: ${err instanceof Error ? err.message : String(err)}`,
-                            }],
+                        content: [{ type: 'text', text: `Error creating root page: ${errorMessage(err)}` }],
                     };
                 }
             }
-            // Build a map from relativePath to node for parent lookups
+            // Build a map from relativePath → node for parent lookups, and a separate
+            // map for resolved page IDs so we never mutate the input node objects.
             const nodeMap = new Map();
+            const resolvedIds = new Map(); // relativePath → pageId
             for (const node of nodes) {
                 nodeMap.set(node.relativePath, node);
             }
@@ -643,7 +715,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                     else {
                         const parentNode = nodeMap.get(node.parentRelativePath);
-                        parentId = parentNode?.resolvedPageId;
+                        parentId = parentNode ? resolvedIds.get(parentNode.relativePath) : undefined;
                     }
                     if (!parentId) {
                         return {
@@ -658,8 +730,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         const content = node.markdownFile?.content ?? '';
                         const pageId = node.markdownFile?.pageId;
                         const result = await publishMarkdown(content, node.title, input.spaceKey, pageId, parentId, true);
-                        // Store resolved page ID for children
-                        node.resolvedPageId = result.pageId;
+                        if (result.pageId) {
+                            resolvedIds.set(node.relativePath, result.pageId);
+                        }
                         return {
                             relativePath: node.relativePath,
                             title: node.title,
@@ -677,7 +750,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             title: node.title,
                             success: false,
                             isDirectory: node.isDirectory,
-                            error: err instanceof Error ? err.message : String(err),
+                            error: errorMessage(err),
                         };
                     }
                 })));
@@ -691,18 +764,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     titleToUrl.set(r.title, r.url);
                 }
             }
-            // Find nodes with wiki links that need re-publishing
-            const nodesWithLinks = nodes.filter((n) => n.markdownFile && hasWikiLinks(n.markdownFile.content) && n.resolvedPageId);
+            // Find nodes with wiki links that were successfully published and need re-publishing
+            const nodesWithLinks = nodes.filter((n) => n.markdownFile && hasWikiLinks(n.markdownFile.content) && resolvedIds.has(n.relativePath));
             if (nodesWithLinks.length > 0 && titleToUrl.size > 0) {
                 const linkResults = await Promise.all(nodesWithLinks.map((node) => limit(async () => {
                     try {
                         const resolvedMarkdown = resolveWikiLinks(node.markdownFile.content, titleToUrl);
-                        const result = await publishMarkdown(resolvedMarkdown, node.title, input.spaceKey, node.resolvedPageId, undefined, // don't reparent on second pass
+                        const result = await publishMarkdown(resolvedMarkdown, node.title, input.spaceKey, resolvedIds.get(node.relativePath), undefined, // don't reparent on second pass
                         true);
                         return { relativePath: node.relativePath, title: node.title, success: true, version: result.version };
                     }
-                    catch {
-                        return { relativePath: node.relativePath, title: node.title, success: false };
+                    catch (err) {
+                        return { relativePath: node.relativePath, title: node.title, success: false, error: errorMessage(err) };
                     }
                 })));
                 const linkedCount = linkResults.filter((r) => r.success).length;
@@ -757,10 +830,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
     catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
         return {
             isError: true,
-            content: [{ type: 'text', text: `Error: ${message}` }],
+            content: [{ type: 'text', text: `Error: ${errorMessage(err)}` }],
         };
     }
 });

package/dist/kroki/KrokiDiagramPlugin.js

@@ -20,7 +20,7 @@ export class KrokiDiagramPlugin {
         const nodes = filter(adf, (node) => node.type === 'codeBlock' &&
             (node.attrs || {})?.['language'] === this.diagramType);
         const charts = new Set(nodes.map((node) => {
-            const details = getDiagramFileName(this.diagramType, node?.content?.at(0)?.text, this.outputFormat);
+            const details = getDiagramFileName(this.diagramType, node?.content?.[0]?.text, this.outputFormat);
             return {
                 name: details.uploadFilename,
                 data: details.text,
@@ -29,17 +29,22 @@ export class KrokiDiagramPlugin {
         return Array.from(charts);
     }
     async transform(charts, supportFunctions) {
-        let imageMap = {};
         if (charts.length === 0) {
-            return imageMap;
+            return {};
         }
+        // Render all diagrams in parallel, then upload all results in parallel.
+        // Previously uploads were sequential (N+1); now both phases are concurrent.
         const rendered = await Promise.all(charts.map(async (chart) => {
             const buffer = await this.client.renderDiagram(this.diagramType, chart.data, this.outputFormat);
             return [chart.name, buffer];
         }));
-        for (const [name, buffer] of rendered) {
-            const uploaded = await supportFunctions.uploadBuffer(name, buffer);
-            imageMap = { ...imageMap, [name]: uploaded };
+        const uploaded = await Promise.all(rendered.map(async ([name, buffer]) => {
+            const image = await supportFunctions.uploadBuffer(name, buffer);
+            return [name, image];
+        }));
+        const imageMap = {};
+        for (const [name, image] of uploaded) {
+            imageMap[name] = image;
         }
         return imageMap;
     }
@@ -49,7 +54,7 @@ export class KrokiDiagramPlugin {
             traverse(afterAdf, {
                 codeBlock: (node, _parent) => {
                     if (node?.attrs?.['language'] === this.diagramType) {
-                        const content = node?.content?.at(0)?.text;
+                        const content = node?.content?.[0]?.text;
                         if (!content) {
                             return;
                         }

package/dist/loader.js

@@ -22,7 +22,10 @@ function tryResolveFile(filePath) {
           return pathToFileURL(resolved).href;
         }
       }
-    } catch {}
+    } catch (err) {
+      // Non-fatal: if package.json is unparseable we simply can't resolve this path.
+      process.stderr.write(`[loader] Failed to parse package.json at ${filePath}: ${err?.message ?? err}\n`);
+    }
   }
   return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neverprepared/mcp-markdown-to-confluence",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "MCP server for converting markdown to Confluence ADF and publishing pages with diagram support via Kroki",
   "type": "module",
   "main": "dist/index.js",