@jgardner04/ghost-mcp-server 1.0.0 → 1.1.1

package/src/mcp_server_improved.js

@@ -1,657 +1,292 @@
 #!/usr/bin/env node
-import {
-  MCPServer,
-  Resource,
-  Tool,
-} from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import { WebSocketServerTransport } from "@modelcontextprotocol/sdk/server/websocket.js";
-import dotenv from "dotenv";
-import { createPostService } from "./services/postService.js";
-import {
-  uploadImage as uploadGhostImage,
-  getTags as getGhostTags,
-  createTag as createGhostTag,
-} from "./services/ghostService.js";
-import { processImage } from "./services/imageProcessingService.js";
-import axios from "axios";
-import { validateImageUrl, createSecureAxiosConfig } from "./utils/urlValidator.js";
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { v4 as uuidv4 } from "uuid";
-import express from "express";
-import { WebSocketServer } from "ws";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import dotenv from 'dotenv';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
 
 // Load environment variables
 dotenv.config();
 
-console.log("Initializing MCP Server...");
+// Lazy-loaded modules (to avoid Node.js v25 Buffer compatibility issues at startup)
+let ghostService = null;
+let postService = null;
+let imageProcessingService = null;
+let urlValidator = null;
 
-// Define the server instance
-const mcpServer = new MCPServer({
-  metadata: {
-    name: "Ghost CMS Manager",
-    description:
-      "MCP Server to manage a Ghost CMS instance using the Admin API.",
-    version: "1.0.0",
-  },
-});
-
-// --- Error Response Standardization ---
-class MCPError extends Error {
-  constructor(message, code = "UNKNOWN_ERROR", details = {}) {
-    super(message);
-    this.code = code;
-    this.details = details;
+const loadServices = async () => {
+  if (!ghostService) {
+    ghostService = await import('./services/ghostService.js');
+    postService = await import('./services/postService.js');
+    imageProcessingService = await import('./services/imageProcessingService.js');
+    urlValidator = await import('./utils/urlValidator.js');
   }
-}
+};
 
-const handleToolError = (error, toolName) => {
-  console.error(`Error in tool ${toolName}:`, error);
-  
-  // Standardized error response
-  return {
-    error: {
-      code: error.code || "TOOL_EXECUTION_ERROR",
-      message: error.message || "An unexpected error occurred",
-      tool: toolName,
-      details: error.details || {},
-      timestamp: new Date().toISOString(),
-    }
-  };
+// Generate UUID without external dependency
+const generateUuid = () => crypto.randomUUID();
+
+// Helper function for default alt text
+const getDefaultAltText = (filePath) => {
+  try {
+    const originalFilename = path.basename(filePath).split('.').slice(0, -1).join('.');
+    const nameWithoutIds = originalFilename
+      .replace(/^(processed-|mcp-download-|mcp-upload-)\d+-\d+-?/, '')
+      .replace(/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}-?/, '');
+    return nameWithoutIds.replace(/[-_]/g, ' ').trim() || 'Uploaded image';
+  } catch (_e) {
+    return 'Uploaded image';
+  }
 };
 
-// --- Define Resources ---
+// Create server instance with new API
+const server = new McpServer({
+  name: 'ghost-mcp-server',
+  version: '1.0.0',
+});
 
-console.log("Defining MCP Resources...");
+// --- Register Tools ---
 
-// Ghost Tag Resource
-const ghostTagResource = new Resource({
-  name: "ghost/tag",
-  description: "Represents a tag in Ghost CMS.",
-  schema: {
-    type: "object",
-    properties: {
-      id: { type: "string", description: "Unique ID of the tag" },
-      name: { type: "string", description: "The name of the tag" },
-      slug: { type: "string", description: "URL-friendly version of the name" },
-      description: {
-        type: ["string", "null"],
-        description: "Optional description for the tag",
-      },
-    },
-    required: ["id", "name", "slug"],
+// Get Tags Tool
+server.tool(
+  'ghost_get_tags',
+  'Retrieves a list of tags from Ghost CMS. Can optionally filter by tag name.',
+  {
+    name: z
+      .string()
+      .optional()
+      .describe('Filter tags by exact name. If omitted, all tags are returned.'),
   },
-  // Resource fetching handler
-  async fetch(uri) {
+  async ({ name }) => {
+    console.error(`Executing tool: ghost_get_tags`);
     try {
-      // Extract tag ID from URI (e.g., "ghost/tag/123")
-      const tagId = uri.split("/").pop();
-      const tags = await getGhostTags();
-      const tag = tags.find(t => t.id === tagId || t.slug === tagId);
-      
-      if (!tag) {
-        throw new MCPError(`Tag not found: ${tagId}`, "RESOURCE_NOT_FOUND");
+      await loadServices();
+      const tags = await ghostService.getTags();
+      let result = tags;
+
+      if (name) {
+        result = tags.filter((tag) => tag.name.toLowerCase() === name.toLowerCase());
+        console.error(`Filtered tags by name "${name}". Found ${result.length} match(es).`);
+      } else {
+        console.error(`Retrieved ${tags.length} tags from Ghost.`);
       }
-      
-      return tag;
-    } catch (error) {
-      return handleToolError(error, "ghost_tag_fetch");
-    }
-  }
-});
-mcpServer.addResource(ghostTagResource);
-console.log(`Added Resource: ${ghostTagResource.name}`);
 
-// Ghost Post Resource
-const ghostPostResource = new Resource({
-  name: "ghost/post",
-  description: "Represents a post in Ghost CMS.",
-  schema: {
-    type: "object",
-    properties: {
-      id: { type: "string", description: "Unique ID of the post" },
-      uuid: { type: "string", description: "UUID of the post" },
-      title: { type: "string", description: "The title of the post" },
-      slug: {
-        type: "string",
-        description: "URL-friendly version of the title",
-      },
-      html: {
-        type: ["string", "null"],
-        description: "The post content as HTML",
-      },
-      plaintext: {
-        type: ["string", "null"],
-        description: "The post content as plain text",
-      },
-      feature_image: {
-        type: ["string", "null"],
-        description: "URL of the featured image",
-      },
-      feature_image_alt: {
-        type: ["string", "null"],
-        description: "Alt text for the featured image",
-      },
-      feature_image_caption: {
-        type: ["string", "null"],
-        description: "Caption for the featured image",
-      },
-      featured: {
-        type: "boolean",
-        description: "Whether the post is featured",
-      },
-      status: {
-        type: "string",
-        enum: ["draft", "published", "scheduled"],
-        description: "The status of the post",
-      },
-      visibility: {
-        type: "string",
-        enum: ["public", "members", "paid", "tiers"],
-        description: "The visibility level of the post",
-      },
-      created_at: {
-        type: "string",
-        format: "date-time",
-        description: "Date/time when the post was created",
-      },
-      updated_at: {
-        type: "string",
-        format: "date-time",
-        description: "Date/time when the post was last updated",
-      },
-      published_at: {
-        type: ["string", "null"],
-        format: "date-time",
-        description: "Date/time when the post was published",
-      },
-      custom_excerpt: {
-        type: ["string", "null"],
-        description: "Custom excerpt for the post",
-      },
-      tags: {
-        type: "array",
-        items: { $ref: "ghost/tag#/schema" },
-        description: "Associated tags",
-      },
-      meta_title: {
-        type: ["string", "null"],
-        description: "Custom meta title for SEO",
-      },
-      meta_description: {
-        type: ["string", "null"],
-        description: "Custom meta description for SEO",
-      },
-    },
-    required: ["id", "uuid", "title", "slug", "status"],
-  },
-  // Resource fetching handler  
-  async fetch(uri) {
-    try {
-      // Extract post ID from URI (e.g., "ghost/post/123")
-      const postId = uri.split("/").pop();
-      
-      // You'll need to implement a getPost service method
-      // For now, returning an error as this would require adding to ghostService.js
-      throw new MCPError(
-        "Post fetching not yet implemented",
-        "NOT_IMPLEMENTED",
-        { postId }
-      );
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+      };
     } catch (error) {
-      return handleToolError(error, "ghost_post_fetch");
+      console.error(`Error in ghost_get_tags:`, error);
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true,
+      };
     }
   }
-});
-mcpServer.addResource(ghostPostResource);
-console.log(`Added Resource: ${ghostPostResource.name}`);
+);
 
-// --- Define Tools (with improved error handling) ---
-
-console.log("Defining MCP Tools...");
-
-// Create Post Tool
-const createPostTool = new Tool({
-  name: "ghost_create_post",
-  description: "Creates a new post in Ghost CMS.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      title: {
-        type: "string",
-        description: "The title of the post.",
-      },
-      html: {
-        type: "string",
-        description: "The HTML content of the post.",
-      },
-      status: {
-        type: "string",
-        enum: ["draft", "published", "scheduled"],
-        default: "draft",
-        description:
-          "The status of the post. Use 'scheduled' with a future published_at date.",
-      },
-      tags: {
-        type: "array",
-        items: { type: "string" },
-        description:
-          "Optional: List of tag names to associate with the post. Tags will be created if they don't exist.",
-      },
-      published_at: {
-        type: "string",
-        format: "date-time",
-        description:
-          "Optional: ISO 8601 date/time to publish the post. Required if status is 'scheduled'.",
-      },
-      custom_excerpt: {
-        type: "string",
-        description: "Optional: A custom short summary for the post.",
-      },
-      feature_image: {
-        type: "string",
-        format: "url",
-        description:
-          "Optional: URL of the image (e.g., from ghost_upload_image tool) to use as the featured image.",
-      },
-      feature_image_alt: {
-        type: "string",
-        description: "Optional: Alt text for the featured image.",
-      },
-      feature_image_caption: {
-        type: "string",
-        description: "Optional: Caption for the featured image.",
-      },
-      meta_title: {
-        type: "string",
-        description:
-          "Optional: Custom title for SEO (max 300 chars). Defaults to post title if omitted.",
-      },
-      meta_description: {
-        type: "string",
-        description:
-          "Optional: Custom description for SEO (max 500 chars). Defaults to excerpt or generated summary if omitted.",
-      },
-    },
-    required: ["title", "html"],
-  },
-  outputSchema: {
-    $ref: "ghost/post#/schema",
+// Create Tag Tool
+server.tool(
+  'ghost_create_tag',
+  'Creates a new tag in Ghost CMS.',
+  {
+    name: z.string().describe('The name of the tag.'),
+    description: z.string().optional().describe('A description for the tag.'),
+    slug: z
+      .string()
+      .optional()
+      .describe(
+        'A URL-friendly slug for the tag. Will be auto-generated from the name if omitted.'
+      ),
   },
-  implementation: async (input) => {
-    console.log(
-      `Executing tool: ${createPostTool.name} with input keys:`,
-      Object.keys(input)
-    );
+  async ({ name, description, slug }) => {
+    console.error(`Executing tool: ghost_create_tag with name: ${name}`);
     try {
-      const createdPost = await createPostService(input);
-      console.log(
-        `Tool ${createPostTool.name} executed successfully. Post ID: ${createdPost.id}`
-      );
-      return createdPost;
+      await loadServices();
+      const createdTag = await ghostService.createTag({ name, description, slug });
+      console.error(`Tag created successfully. Tag ID: ${createdTag.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(createdTag, null, 2) }],
+      };
     } catch (error) {
-      return handleToolError(error, createPostTool.name);
+      console.error(`Error in ghost_create_tag:`, error);
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true,
+      };
     }
-  },
-});
-mcpServer.addTool(createPostTool);
-console.log(`Added Tool: ${createPostTool.name}`);
+  }
+);
 
 // Upload Image Tool
-const uploadImageTool = new Tool({
-  name: "ghost_upload_image",
-  description:
-    "Downloads an image from a URL, processes it, uploads it to Ghost CMS, and returns the final Ghost image URL and alt text.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      imageUrl: {
-        type: "string",
-        format: "url",
-        description: "The publicly accessible URL of the image to upload.",
-      },
-      alt: {
-        type: "string",
-        description:
-          "Optional: Alt text for the image. If omitted, a default will be generated from the filename.",
-      },
-    },
-    required: ["imageUrl"],
-  },
-  outputSchema: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        format: "url",
-        description: "The final URL of the image hosted on Ghost.",
-      },
-      alt: {
-        type: "string",
-        description: "The alt text determined for the image.",
-      },
-    },
-    required: ["url", "alt"],
+server.tool(
+  'ghost_upload_image',
+  'Downloads an image from a URL, processes it, uploads it to Ghost CMS, and returns the final Ghost image URL and alt text.',
+  {
+    imageUrl: z.string().describe('The publicly accessible URL of the image to upload.'),
+    alt: z
+      .string()
+      .optional()
+      .describe(
+        'Alt text for the image. If omitted, a default will be generated from the filename.'
+      ),
   },
-  implementation: async (input) => {
-    console.log(
-      `Executing tool: ${uploadImageTool.name} for URL:`,
-      input.imageUrl
-    );
-    const { imageUrl, alt } = input;
+  async ({ imageUrl, alt }) => {
+    console.error(`Executing tool: ghost_upload_image for URL: ${imageUrl}`);
     let downloadedPath = null;
     let processedPath = null;
 
     try {
-      // --- 1. Validate URL for SSRF protection ---
-      const urlValidation = validateImageUrl(imageUrl);
+      await loadServices();
+
+      // 1. Validate URL for SSRF protection
+      const urlValidation = urlValidator.validateImageUrl(imageUrl);
       if (!urlValidation.isValid) {
         throw new Error(`Invalid image URL: ${urlValidation.error}`);
       }
-      
-      // --- 2. Download the image with security controls ---
-      const axiosConfig = createSecureAxiosConfig(urlValidation.sanitizedUrl);
+
+      // 2. Download the image with security controls
+      const axiosConfig = urlValidator.createSecureAxiosConfig(urlValidation.sanitizedUrl);
       const response = await axios(axiosConfig);
       const tempDir = os.tmpdir();
-      const extension = path.extname(imageUrl.split("?")[0]) || ".tmp";
+      const extension = path.extname(imageUrl.split('?')[0]) || '.tmp';
       const originalFilenameHint =
-        path.basename(imageUrl.split("?")[0]) ||
-        `image-${uuidv4()}${extension}`;
-      downloadedPath = path.join(
-        tempDir,
-        `mcp-download-${uuidv4()}${extension}`
-      );
+        path.basename(imageUrl.split('?')[0]) || `image-${generateUuid()}${extension}`;
+      downloadedPath = path.join(tempDir, `mcp-download-${generateUuid()}${extension}`);
 
       const writer = fs.createWriteStream(downloadedPath);
       response.data.pipe(writer);
 
       await new Promise((resolve, reject) => {
-        writer.on("finish", resolve);
-        writer.on("error", reject);
+        writer.on('finish', resolve);
+        writer.on('error', reject);
       });
-      console.log(`Downloaded image to temporary path: ${downloadedPath}`);
+      console.error(`Downloaded image to temporary path: ${downloadedPath}`);
 
-      // --- 2. Process the image ---
-      processedPath = await processImage(downloadedPath, tempDir);
-      console.log(`Processed image path: ${processedPath}`);
+      // 3. Process the image
+      processedPath = await imageProcessingService.processImage(downloadedPath, tempDir);
+      console.error(`Processed image path: ${processedPath}`);
 
-      // --- 3. Determine Alt Text ---
+      // 4. Determine Alt Text
       const defaultAlt = getDefaultAltText(originalFilenameHint);
       const finalAltText = alt || defaultAlt;
-      console.log(`Using alt text: "${finalAltText}"`);
+      console.error(`Using alt text: "${finalAltText}"`);
 
-      // --- 4. Upload processed image to Ghost ---
-      const uploadResult = await uploadGhostImage(processedPath);
-      console.log(`Uploaded processed image to Ghost: ${uploadResult.url}`);
+      // 5. Upload processed image to Ghost
+      const uploadResult = await ghostService.uploadImage(processedPath);
+      console.error(`Uploaded processed image to Ghost: ${uploadResult.url}`);
 
-      // --- 5. Return result ---
-      return {
+      // 6. Return result
+      const result = {
         url: uploadResult.url,
         alt: finalAltText,
       };
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+      };
     } catch (error) {
-      return handleToolError(
-        new MCPError(
-          `Failed to upload image from URL ${imageUrl}`,
-          "IMAGE_UPLOAD_ERROR",
-          { imageUrl, originalError: error.message }
-        ),
-        uploadImageTool.name
-      );
+      console.error(`Error in ghost_upload_image:`, error);
+      return {
+        content: [{ type: 'text', text: `Error uploading image: ${error.message}` }],
+        isError: true,
+      };
     } finally {
-      // --- 6. Cleanup temporary files ---
+      // Cleanup temporary files
       if (downloadedPath) {
         fs.unlink(downloadedPath, (err) => {
-          if (err)
-            console.error(
-              "Error deleting temporary downloaded file:",
-              downloadedPath,
-              err
-            );
+          if (err) console.error('Error deleting temporary downloaded file:', downloadedPath, err);
         });
       }
       if (processedPath && processedPath !== downloadedPath) {
         fs.unlink(processedPath, (err) => {
-          if (err)
-            console.error(
-              "Error deleting temporary processed file:",
-              processedPath,
-              err
-            );
+          if (err) console.error('Error deleting temporary processed file:', processedPath, err);
         });
       }
     }
-  },
-});
-
-// Helper function for default alt text
-const getDefaultAltText = (filePath) => {
-  try {
-    const originalFilename = path
-      .basename(filePath)
-      .split(".")
-      .slice(0, -1)
-      .join(".");
-    const nameWithoutIds = originalFilename
-      .replace(/^(processed-|mcp-download-|mcp-upload-)\d+-\d+-?/, "")
-      .replace(/^[a-f0-9]{8}-(?:[a-f0-9]{4}-){3}[a-f0-9]{12}-?/, "");
-    return nameWithoutIds.replace(/[-_]/g, " ").trim() || "Uploaded image";
-  } catch (e) {
-    return "Uploaded image";
   }
-};
-
-mcpServer.addTool(uploadImageTool);
-console.log(`Added Tool: ${uploadImageTool.name}`);
+);
 
-// Get Tags Tool
-const getTagsTool = new Tool({
-  name: "ghost_get_tags",
-  description:
-    "Retrieves a list of tags from Ghost CMS. Can optionally filter by tag name.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description:
-          "Optional: Filter tags by exact name. If omitted, all tags are returned.",
-      },
-    },
-  },
-  outputSchema: {
-    type: "array",
-    items: { $ref: "ghost/tag#/schema" },
+// Create Post Tool
+server.tool(
+  'ghost_create_post',
+  'Creates a new post in Ghost CMS.',
+  {
+    title: z.string().describe('The title of the post.'),
+    html: z.string().describe('The HTML content of the post.'),
+    status: z
+      .enum(['draft', 'published', 'scheduled'])
+      .optional()
+      .describe("The status of the post. Defaults to 'draft'."),
+    tags: z
+      .array(z.string())
+      .optional()
+      .describe(
+        "List of tag names to associate with the post. Tags will be created if they don't exist."
+      ),
+    published_at: z
+      .string()
+      .optional()
+      .describe("ISO 8601 date/time to publish the post. Required if status is 'scheduled'."),
+    custom_excerpt: z.string().optional().describe('A custom short summary for the post.'),
+    feature_image: z
+      .string()
+      .optional()
+      .describe(
+        'URL of the image (e.g., from ghost_upload_image tool) to use as the featured image.'
+      ),
+    feature_image_alt: z.string().optional().describe('Alt text for the featured image.'),
+    feature_image_caption: z.string().optional().describe('Caption for the featured image.'),
+    meta_title: z
+      .string()
+      .optional()
+      .describe('Custom title for SEO (max 300 chars). Defaults to post title if omitted.'),
+    meta_description: z
+      .string()
+      .optional()
+      .describe(
+        'Custom description for SEO (max 500 chars). Defaults to excerpt or generated summary if omitted.'
+      ),
   },
-  implementation: async (input) => {
-    console.log(`Executing tool: ${getTagsTool.name}`);
+  async (input) => {
+    console.error(`Executing tool: ghost_create_post with title: ${input.title}`);
     try {
-      const tags = await getGhostTags();
-      if (input.name) {
-        const filteredTags = tags.filter(
-          (tag) => tag.name.toLowerCase() === input.name.toLowerCase()
-        );
-        console.log(
-          `Filtered tags by name "${input.name}". Found ${filteredTags.length} match(es).`
-        );
-        return filteredTags;
-      }
-      console.log(`Retrieved ${tags.length} tags from Ghost.`);
-      return tags;
-    } catch (error) {
-      return handleToolError(error, getTagsTool.name);
-    }
-  },
-});
-mcpServer.addTool(getTagsTool);
-console.log(`Added Tool: ${getTagsTool.name}`);
+      await loadServices();
+      const createdPost = await postService.createPostService(input);
+      console.error(`Post created successfully. Post ID: ${createdPost.id}`);
 
-// Create Tag Tool
-const createTagTool = new Tool({
-  name: "ghost_create_tag",
-  description: "Creates a new tag in Ghost CMS.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description: "The name of the tag.",
-      },
-      description: {
-        type: "string",
-        description: "Optional: A description for the tag.",
-      },
-      slug: {
-        type: "string",
-        pattern: "^[a-z0-9\\-]+$",
-        description:
-          "Optional: A URL-friendly slug for the tag. Will be auto-generated from the name if omitted.",
-      },
-    },
-    required: ["name"],
-  },
-  outputSchema: {
-    $ref: "ghost/tag#/schema",
-  },
-  implementation: async (input) => {
-    console.log(
-      `Executing tool: ${createTagTool.name} with name:`,
-      input.name
-    );
-    try {
-      const createdTag = await createGhostTag(input);
-      console.log(
-        `Tool ${createTagTool.name} executed successfully. Tag ID: ${createdTag.id}`
-      );
-      return createdTag;
+      return {
+        content: [{ type: 'text', text: JSON.stringify(createdPost, null, 2) }],
+      };
     } catch (error) {
-      return handleToolError(error, createTagTool.name);
-    }
-  },
-});
-mcpServer.addTool(createTagTool);
-console.log(`Added Tool: ${createTagTool.name}`);
-
-// --- Transport Configuration ---
-
-/**
- * Start MCP Server with specified transport
- * @param {string} transport - Transport type: 'stdio', 'http', 'websocket'
- * @param {object} options - Transport-specific options
- */
-const startMCPServer = async (transport = 'http', options = {}) => {
-  try {
-    console.log(`Starting MCP Server with ${transport} transport...`);
-    
-    switch (transport) {
-      case 'stdio':
-        // Standard I/O transport - best for CLI tools
-        const stdioTransport = new StdioServerTransport();
-        await mcpServer.connect(stdioTransport);
-        console.log("MCP Server running on stdio transport");
-        break;
-        
-      case 'http':
-      case 'sse':
-        // HTTP with Server-Sent Events - good for web clients
-        const port = options.port || 3001;
-        const app = express();
-        
-        // CORS configuration for web clients
-        app.use((req, res, next) => {
-          res.header('Access-Control-Allow-Origin', options.cors || '*');
-          res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-          res.header('Access-Control-Allow-Headers', 'Content-Type');
-          next();
-        });
-        
-        // SSE endpoint
-        const sseTransport = new SSEServerTransport();
-        app.get('/mcp/sse', sseTransport.handler());
-        
-        // Health check
-        app.get('/mcp/health', (req, res) => {
-          res.json({
-            status: 'ok',
-            transport: 'sse',
-            resources: mcpServer.listResources().map(r => r.name),
-            tools: mcpServer.listTools().map(t => t.name),
-          });
-        });
-        
-        await mcpServer.connect(sseTransport);
-        
-        const server = app.listen(port, () => {
-          console.log(`MCP Server (SSE) listening on port ${port}`);
-          console.log(`SSE endpoint: http://localhost:${port}/mcp/sse`);
-          console.log(`Health check: http://localhost:${port}/mcp/health`);
-        });
-        
-        // Store server instance for cleanup
-        mcpServer._httpServer = server;
-        break;
-        
-      case 'websocket':
-        // WebSocket transport - best for real-time bidirectional communication
-        const wsPort = options.port || 3001;
-        const wss = new WebSocketServer({ port: wsPort });
-        
-        wss.on('connection', async (ws) => {
-          console.log('New WebSocket connection');
-          const wsTransport = new WebSocketServerTransport(ws);
-          await mcpServer.connect(wsTransport);
-        });
-        
-        console.log(`MCP Server (WebSocket) listening on port ${wsPort}`);
-        console.log(`WebSocket URL: ws://localhost:${wsPort}`);
-        
-        // Store WebSocket server instance for cleanup
-        mcpServer._wss = wss;
-        break;
-        
-      default:
-        throw new Error(`Unknown transport type: ${transport}`);
+      console.error(`Error in ghost_create_post:`, error);
+      return {
+        content: [{ type: 'text', text: `Error creating post: ${error.message}` }],
+        isError: true,
+      };
     }
-    
-    console.log("Available Resources:", mcpServer.listResources().map(r => r.name));
-    console.log("Available Tools:", mcpServer.listTools().map(t => t.name));
-    
-  } catch (error) {
-    console.error("Failed to start MCP Server:", error);
-    process.exit(1);
   }
-};
+);
 
-// Graceful shutdown handler
-const shutdown = async () => {
-  console.log("\nShutting down MCP Server...");
-  
-  if (mcpServer._httpServer) {
-    mcpServer._httpServer.close();
-  }
-  
-  if (mcpServer._wss) {
-    mcpServer._wss.close();
-  }
-  
-  await mcpServer.close();
-  process.exit(0);
-};
+// --- Main Entry Point ---
 
-process.on('SIGINT', shutdown);
-process.on('SIGTERM', shutdown);
+async function main() {
+  console.error('Starting Ghost MCP Server...');
 
-// Export the server instance and start function
-export { mcpServer, startMCPServer, MCPError };
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 
-// If running directly, start with transport from environment or default to HTTP
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const transport = process.env.MCP_TRANSPORT || 'http';
-  const port = parseInt(process.env.MCP_PORT || '3001');
-  const cors = process.env.MCP_CORS || '*';
-  
-  startMCPServer(transport, { port, cors });
-}
+  console.error('Ghost MCP Server running on stdio transport');
+  console.error(
+    'Available tools: ghost_get_tags, ghost_create_tag, ghost_upload_image, ghost_create_post'
+  );
+}
+
+main().catch((error) => {
+  console.error('Fatal error starting MCP server:', error);
+  process.exit(1);
+});