@neverprepared/mcp-markdown-to-confluence 1.1.0 → 1.1.4

package/bin/mcp-markdown-to-confluence.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+register(pathToFileURL(resolve(__dirname, '..', 'dist', 'loader.js')));
+
+await import(pathToFileURL(resolve(__dirname, '..', 'dist', 'index.js')));

package/dist/index.js

@@ -5,7 +5,12 @@ import { z } from 'zod';
 import { ConfluenceClient } from 'confluence.js';
 import matter from 'gray-matter';
 import { readFile } from 'fs/promises';
-import { parseMarkdownToADF, renderADFDoc, executeADFProcessingPipeline, createPublisherFunctions, MermaidRendererPlugin, } from '@markdown-confluence/lib';
+// 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';
+import { renderADFDoc } from '@markdown-confluence/lib/dist/ADFToMarkdown.js';
+import { executeADFProcessingPipeline, createPublisherFunctions, } from '@markdown-confluence/lib/dist/ADFProcessingPlugins/types.js';
+import { MermaidRendererPlugin } from '@markdown-confluence/lib/dist/ADFProcessingPlugins/MermaidRendererPlugin.js';
 import { KrokiClient, KrokiMermaidRenderer, KrokiDiagramPlugin } from './kroki/index.js';
 // ---------------------------------------------------------------------------
 // Environment
@@ -18,10 +23,29 @@ const KROKI_URL = process.env.KROKI_URL ?? 'http://localhost:8371';
 // Kroki client
 // ---------------------------------------------------------------------------
 const krokiClient = new KrokiClient(KROKI_URL);
+// Diagram types and their preferred output format
+// PNG is preferred when supported; SVG is the universal fallback
+const KROKI_DIAGRAM_CONFIGS = [
+    { type: 'plantuml', format: 'png' },
+    { type: 'graphviz', format: 'png' },
+    { type: 'dot', format: 'png' },
+    { type: 'ditaa', format: 'svg' },
+    { type: 'nomnoml', format: 'svg' },
+    { type: 'd2', format: 'svg' },
+    { type: 'dbml', format: 'svg' },
+    { type: 'erd', format: 'svg' },
+    { type: 'svgbob', format: 'svg' },
+    { type: 'pikchr', format: 'svg' },
+    { type: 'bytefield', format: 'svg' },
+    { type: 'wavedrom', format: 'svg' },
+    { type: 'vega', format: 'svg' },
+    { type: 'vega-lite', format: 'svg' },
+    { type: 'bpmn', format: 'svg' },
+    { type: 'c4plantuml', format: 'png' },
+];
 const SUPPORTED_DIAGRAM_TYPES = [
-    'mermaid', 'plantuml', 'graphviz', 'dot', 'd2', 'ditaa', 'nomnoml',
-    'svgbob', 'pikchr', 'bytefield', 'wavedrom', 'vega', 'vega-lite',
-    'excalidraw', 'bpmn', 'erd', 'dbml', 'c4plantuml',
+    'mermaid',
+    ...KROKI_DIAGRAM_CONFIGS.map((c) => c.type),
 ];
 // ---------------------------------------------------------------------------
 // Confluence client
@@ -140,9 +164,7 @@ async function publishMarkdown(markdown, title, spaceKey, pageId, parentId, skip
     // Run ADF processing pipeline (renders diagrams via Kroki)
     const finalAdf = await executeADFProcessingPipeline([
         new MermaidRendererPlugin(new KrokiMermaidRenderer(krokiClient)),
-        ...SUPPORTED_DIAGRAM_TYPES
-            .filter((t) => t !== 'mermaid')
-            .map((t) => new KrokiDiagramPlugin(t, krokiClient)),
+        ...KROKI_DIAGRAM_CONFIGS.map((c) => new KrokiDiagramPlugin(c.type, krokiClient, c.format)),
     ], adf, publisherFunctions);
     // Update the page with the final ADF
     const updateParams = {

package/dist/kroki/KrokiDiagramPlugin.js

@@ -1,16 +1,17 @@
 import { filter, traverse } from '@atlaskit/adf-utils/traverse';
 import SparkMD5 from 'spark-md5';
-function getDiagramFileName(diagramType, content) {
+function getDiagramFileName(diagramType, content, outputFormat) {
     const text = content ?? `${diagramType} placeholder`;
     const hash = SparkMD5.hash(text);
-    const uploadFilename = `RenderedKrokiChart-${diagramType}-${hash}.png`;
+    const ext = outputFormat === 'png' ? 'png' : 'svg';
+    const uploadFilename = `RenderedKrokiChart-${diagramType}-${hash}.${ext}`;
     return { uploadFilename, text };
 }
 export class KrokiDiagramPlugin {
     diagramType;
     client;
     outputFormat;
-    constructor(diagramType, client, outputFormat = 'png') {
+    constructor(diagramType, client, outputFormat = 'svg') {
         this.diagramType = diagramType;
         this.client = client;
         this.outputFormat = outputFormat;
@@ -19,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);
+            const details = getDiagramFileName(this.diagramType, node?.content?.at(0)?.text, this.outputFormat);
             return {
                 name: details.uploadFilename,
                 data: details.text,
@@ -52,7 +53,7 @@ export class KrokiDiagramPlugin {
                         if (!content) {
                             return;
                         }
-                        const filename = getDiagramFileName(this.diagramType, content);
+                        const filename = getDiagramFileName(this.diagramType, content, this.outputFormat);
                         if (!imageMap[filename.uploadFilename]) {
                             return;
                         }

package/dist/loader.js

@@ -0,0 +1,57 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { resolve as pathResolve, dirname } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+
+function tryResolveFile(filePath) {
+  // Direct .js extension
+  if (existsSync(filePath + '.js')) {
+    return pathToFileURL(filePath + '.js').href;
+  }
+  // Directory with index.js
+  if (existsSync(filePath + '/index.js')) {
+    return pathToFileURL(filePath + '/index.js').href;
+  }
+  // Directory with package.json (module or main field)
+  if (existsSync(filePath + '/package.json')) {
+    try {
+      const pkg = JSON.parse(readFileSync(filePath + '/package.json', 'utf-8'));
+      const entry = pkg.module || pkg.main;
+      if (entry) {
+        const resolved = pathResolve(filePath, entry);
+        if (existsSync(resolved)) {
+          return pathToFileURL(resolved).href;
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+export async function load(url, context, nextLoad) {
+  if (url.endsWith('.json')) {
+    return nextLoad(url, { ...context, importAttributes: { type: 'json' } });
+  }
+  return nextLoad(url, context);
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (err) {
+    if (err?.code === 'ERR_MODULE_NOT_FOUND' || err?.code === 'ERR_UNSUPPORTED_DIR_IMPORT') {
+      // Try from the error's resolved URL
+      if (err.url) {
+        const resolved = tryResolveFile(fileURLToPath(err.url));
+        if (resolved) return { url: resolved, shortCircuit: true };
+      }
+
+      // Try from parent for relative specifiers
+      if (specifier.startsWith('.') && context.parentURL) {
+        const parentPath = dirname(fileURLToPath(context.parentURL));
+        const resolved = tryResolveFile(pathResolve(parentPath, specifier));
+        if (resolved) return { url: resolved, shortCircuit: true };
+      }
+    }
+    throw err;
+  }
+}

package/package.json

@@ -1,25 +1,26 @@
 {
   "name": "@neverprepared/mcp-markdown-to-confluence",
-  "version": "1.1.0",
+  "version": "1.1.4",
   "description": "MCP server for converting markdown to Confluence ADF and publishing pages with diagram support via Kroki",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "mcp-markdown-to-confluence": "dist/index.js"
+    "mcp-markdown-to-confluence": "bin/mcp-markdown-to-confluence.js"
   },
   "files": [
+    "bin",
     "dist",
     "docker",
     "scripts"
   ],
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "node --watch dist/index.js",
+    "build": "tsc && cp src/loader.js dist/loader.js",
+    "start": "node bin/mcp-markdown-to-confluence.js",
+    "dev": "node --watch bin/mcp-markdown-to-confluence.js",
     "postinstall": "sh scripts/postinstall.sh"
   },
   "dependencies": {
-    "@markdown-confluence/lib": "^5.5.2",
+    "@markdown-confluence/lib": "5.5.2",
     "@modelcontextprotocol/sdk": "^1.10.1",
     "confluence.js": "^1.6.3",
     "gray-matter": "^4.0.3",