@dalcontak/blogger-mcp-server 1.0.0

package/src/bloggerService.ts

@@ -0,0 +1,351 @@
+import { google, blogger_v3 } from 'googleapis';
+import { BloggerBlog, BloggerPost, BloggerLabel } from './types';
+import { config } from './config';
+
+/**
+ * Custom types to compensate for Blogger API limitations
+ */
+interface BloggerLabelList {
+  kind?: string;
+  items?: BloggerLabel[];
+}
+
+/**
+ * Google Blogger API interaction service
+ * 
+ * Supports two authentication modes:
+ * - OAuth2 (GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN):
+ *   full access (read + write). Required for listBlogs, createPost, updatePost, deletePost.
+ * - API Key (BLOGGER_API_KEY): read-only access to public blogs.
+ *   Works for getBlog, listPosts, getPost, searchPosts, listLabels, getLabel.
+ * 
+ * If both are configured, OAuth2 is used (it covers all operations).
+ */
+export class BloggerService {
+  private blogger: blogger_v3.Blogger;
+  private readonly isOAuth2: boolean;
+
+  /**
+   * Initializes the Blogger service with OAuth2 or API key
+   */
+  constructor() {
+    const { oauth2 } = config;
+    const hasOAuth2 = !!(oauth2.clientId && oauth2.clientSecret && oauth2.refreshToken);
+
+    if (hasOAuth2) {
+      const oauth2Client = new google.auth.OAuth2(
+        oauth2.clientId,
+        oauth2.clientSecret
+      );
+      oauth2Client.setCredentials({ refresh_token: oauth2.refreshToken });
+
+      this.blogger = google.blogger({
+        version: 'v3',
+        auth: oauth2Client,
+        timeout: config.blogger.timeout
+      });
+      this.isOAuth2 = true;
+      console.log('BloggerService initialized with OAuth2 (full access)');
+    } else if (config.blogger.apiKey) {
+      this.blogger = google.blogger({
+        version: 'v3',
+        auth: config.blogger.apiKey,
+        timeout: config.blogger.timeout
+      });
+      this.isOAuth2 = false;
+      console.log('BloggerService initialized with API Key (read-only)');
+    } else {
+      throw new Error(
+        'No authentication configured. ' +
+        'Set BLOGGER_API_KEY (read-only) or ' +
+        'GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN (full access).'
+      );
+    }
+  }
+
+  /**
+   * Checks that OAuth2 authentication is available.
+   * Throws an explicit error if the operation requires OAuth2 and we are in API key mode.
+   */
+  private requireOAuth2(operation: string): void {
+    if (!this.isOAuth2) {
+      throw new Error(
+        `Operation "${operation}" requires OAuth2 authentication. ` +
+        'API Key mode only allows reading public blogs. ' +
+        'Configure GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET and GOOGLE_REFRESH_TOKEN.'
+      );
+    }
+  }
+
+  /**
+   * Lists all blogs for the authenticated user.
+   * Requires OAuth2 (blogs.listByUser with userId: 'self').
+   * @returns Blog list
+   */
+  async listBlogs(): Promise<blogger_v3.Schema$BlogList> {
+    this.requireOAuth2('list_blogs');
+    try {
+      const response = await this.blogger.blogs.listByUser({
+        userId: 'self'
+      });
+      return response.data;
+    } catch (error) {
+      console.error('Error fetching blogs:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieves details of a specific blog
+   * @param blogId ID of the blog to retrieve
+   * @returns Blog details
+   */
+  async getBlog(blogId: string): Promise<blogger_v3.Schema$Blog> {
+    try {
+      const response = await this.blogger.blogs.get({
+        blogId
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Error fetching blog ${blogId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieves a blog by its URL
+   * @param url Blog URL
+   * @returns Blog details
+   */
+  async getBlogByUrl(url: string): Promise<blogger_v3.Schema$Blog> {
+    try {
+      const response = await this.blogger.blogs.getByUrl({
+        url
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Error fetching blog by URL ${url}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Simulates blog creation.
+   * Note: The Blogger API does not actually allow creating a blog via API.
+   * This method simulates the functionality and returns an explanatory error message.
+   * 
+   * @param blogData Blog data to create
+   * @returns Explanatory error message
+   */
+  async createBlog(blogData: Partial<BloggerBlog>): Promise<any> {
+    // Simulate a delay to make the response more realistic
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    // Return an explanatory error message
+    return {
+      error: true,
+      message: "The Google Blogger API does not allow creating a new blog via API. Please create a blog manually on blogger.com.",
+      details: "This limitation is documented by Google. Blogs must be created via the Blogger web interface.",
+      suggestedAction: "Create a blog at https://www.blogger.com, then use its ID with this MCP server."
+    };
+  }
+
+  /**
+   * Lists posts from a blog
+   * @param blogId Blog ID
+   * @param maxResults Maximum number of results to return
+   * @returns Post list
+   */
+  async listPosts(blogId: string, maxResults?: number): Promise<blogger_v3.Schema$PostList> {
+    try {
+      const response = await this.blogger.posts.list({
+        blogId,
+        maxResults: maxResults || config.blogger.maxResults
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Error fetching posts for blog ${blogId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Searches posts in a blog using the native posts.search endpoint of the Blogger API
+   * @param blogId Blog ID
+   * @param query Search term
+   * @param maxResults Maximum number of results to return
+   * @returns List of matching posts
+   */
+  async searchPosts(blogId: string, query: string, maxResults?: number): Promise<blogger_v3.Schema$PostList> {
+    try {
+      const response = await this.blogger.posts.search({
+        blogId,
+        q: query,
+        fetchBodies: true
+      });
+
+      // The search endpoint does not support maxResults directly,
+      // so we truncate client-side if needed
+      const items = response.data.items || [];
+      const limit = maxResults || config.blogger.maxResults;
+
+      return {
+        kind: response.data.kind,
+        items: items.slice(0, limit)
+      };
+    } catch (error) {
+      console.error(`Error searching posts in blog ${blogId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieves a specific post
+   * @param blogId Blog ID
+   * @param postId Post ID
+   * @returns Post details
+   */
+  async getPost(blogId: string, postId: string): Promise<blogger_v3.Schema$Post> {
+    try {
+      const response = await this.blogger.posts.get({
+        blogId,
+        postId
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Error fetching post ${postId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Creates a new post in a blog.
+   * Requires OAuth2.
+   * @param blogId Blog ID
+   * @param postData Post data to create
+   * @returns Created post
+   */
+  async createPost(blogId: string, postData: Partial<BloggerPost>): Promise<blogger_v3.Schema$Post> {
+    this.requireOAuth2('create_post');
+    try {
+      const response = await this.blogger.posts.insert({
+        blogId,
+        requestBody: postData as blogger_v3.Schema$Post
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Error creating post in blog ${blogId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Updates an existing post.
+   * Requires OAuth2.
+   * @param blogId Blog ID
+   * @param postId Post ID
+   * @param postData Post data to update
+   * @returns Updated post
+   */
+  async updatePost(blogId: string, postId: string, postData: Partial<BloggerPost>): Promise<blogger_v3.Schema$Post> {
+    this.requireOAuth2('update_post');
+    try {
+      // Convert types to avoid compilation errors
+      const requestBody: blogger_v3.Schema$Post = {
+        title: postData.title,
+        content: postData.content,
+        labels: postData.labels
+      };
+      
+      const response = await this.blogger.posts.update({
+        blogId,
+        postId,
+        requestBody
+      });
+      return response.data;
+    } catch (error) {
+      console.error(`Error updating post ${postId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Deletes a post.
+   * Requires OAuth2.
+   * @param blogId Blog ID
+   * @param postId Post ID
+   * @returns Deletion status
+   */
+  async deletePost(blogId: string, postId: string): Promise<void> {
+    this.requireOAuth2('delete_post');
+    try {
+      await this.blogger.posts.delete({
+        blogId,
+        postId
+      });
+    } catch (error) {
+      console.error(`Error deleting post ${postId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Lists labels from a blog
+   * @param blogId Blog ID
+   * @returns Label list
+   */
+  async listLabels(blogId: string): Promise<BloggerLabelList> {
+    try {
+      // The Blogger API does not provide a direct endpoint to list labels
+      // We fetch all posts and extract unique labels
+      const response = await this.blogger.posts.list({
+        blogId,
+        maxResults: 50 // Fetch enough posts to extract labels
+      });
+      
+      const posts = response.data.items || [];
+      const labelSet = new Set<string>();
+      
+      // Extract all unique labels from posts
+      posts.forEach(post => {
+        const postLabels = post.labels || [];
+        postLabels.forEach(label => labelSet.add(label));
+      });
+      
+      // Convert to expected format
+      const labels = Array.from(labelSet).map(name => ({ name }));
+      
+      return {
+        kind: 'blogger#labelList',
+        items: labels
+      };
+    } catch (error) {
+      console.error(`Error fetching labels for blog ${blogId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Retrieves a specific label
+   * @param blogId Blog ID
+   * @param labelName Label name
+   * @returns Label details
+   */
+  async getLabel(blogId: string, labelName: string): Promise<BloggerLabel> {
+    try {
+      // The Blogger API does not provide a direct endpoint to retrieve a label
+      // We check if the label exists by listing all labels
+      const labels = await this.listLabels(blogId);
+      const label = labels.items?.find(l => l.name === labelName);
+      
+      if (!label) {
+        throw new Error(`Label ${labelName} not found`);
+      }
+      
+      return label;
+    } catch (error) {
+      console.error(`Error fetching label ${labelName}:`, error);
+      throw error;
+    }
+  }
+}

package/src/config.test.ts

@@ -0,0 +1,121 @@
+/**
+ * Tests for config.ts
+ *
+ * config.ts reads process.env at module load time, so we must
+ * set env vars BEFORE importing. We use jest.isolateModules()
+ * to get a fresh module for each test.
+ */
+
+// Helper to load config with specific env vars
+function loadConfig(env: Record<string, string>) {
+  // Clean all relevant env vars first
+  const keys = [
+    'MCP_MODE', 'MCP_HTTP_HOST', 'MCP_HTTP_PORT',
+    'BLOGGER_API_KEY', 'BLOGGER_MAX_RESULTS', 'BLOGGER_API_TIMEOUT',
+    'GOOGLE_CLIENT_ID', 'GOOGLE_CLIENT_SECRET', 'GOOGLE_REFRESH_TOKEN',
+    'LOG_LEVEL'
+  ];
+  for (const key of keys) {
+    delete process.env[key];
+  }
+  // Set requested env vars
+  for (const [key, value] of Object.entries(env)) {
+    process.env[key] = value;
+  }
+
+  // Force fresh import
+  let config: any;
+  jest.isolateModules(() => {
+    config = require('./config').config;
+  });
+  return config;
+}
+
+beforeEach(() => {
+  jest.resetModules();
+});
+
+describe('config.ts', () => {
+
+  describe('defaults', () => {
+    it('should use default values when no env vars are set', () => {
+      const config = loadConfig({});
+
+      expect(config.mode).toBe('stdio');
+      expect(config.http.host).toBe('0.0.0.0');
+      expect(config.http.port).toBe(3000);
+      expect(config.blogger.apiKey).toBeUndefined();
+      expect(config.blogger.maxResults).toBe(10);
+      expect(config.blogger.timeout).toBe(30000);
+      expect(config.oauth2.clientId).toBeUndefined();
+      expect(config.oauth2.clientSecret).toBeUndefined();
+      expect(config.oauth2.refreshToken).toBeUndefined();
+      expect(config.logging.level).toBe('info');
+    });
+  });
+
+  describe('mode', () => {
+    it('should read MCP_MODE from env', () => {
+      const config = loadConfig({ MCP_MODE: 'http' });
+      expect(config.mode).toBe('http');
+    });
+
+    it('should accept arbitrary mode values (no validation at config level)', () => {
+      const config = loadConfig({ MCP_MODE: 'invalid' });
+      expect(config.mode).toBe('invalid');
+    });
+  });
+
+  describe('http', () => {
+    it('should read host and port from env', () => {
+      const config = loadConfig({ MCP_HTTP_HOST: '127.0.0.1', MCP_HTTP_PORT: '8080' });
+      expect(config.http.host).toBe('127.0.0.1');
+      expect(config.http.port).toBe(8080);
+    });
+
+    it('should return NaN for non-numeric port', () => {
+      const config = loadConfig({ MCP_HTTP_PORT: 'abc' });
+      expect(config.http.port).toBeNaN();
+    });
+  });
+
+  describe('blogger', () => {
+    it('should read API key from env', () => {
+      const config = loadConfig({ BLOGGER_API_KEY: 'test-key-123' });
+      expect(config.blogger.apiKey).toBe('test-key-123');
+    });
+
+    it('should parse maxResults and timeout as integers', () => {
+      const config = loadConfig({ BLOGGER_MAX_RESULTS: '25', BLOGGER_API_TIMEOUT: '60000' });
+      expect(config.blogger.maxResults).toBe(25);
+      expect(config.blogger.timeout).toBe(60000);
+    });
+  });
+
+  describe('oauth2', () => {
+    it('should read all OAuth2 vars from env', () => {
+      const config = loadConfig({
+        GOOGLE_CLIENT_ID: 'cid',
+        GOOGLE_CLIENT_SECRET: 'csec',
+        GOOGLE_REFRESH_TOKEN: 'rtok'
+      });
+      expect(config.oauth2.clientId).toBe('cid');
+      expect(config.oauth2.clientSecret).toBe('csec');
+      expect(config.oauth2.refreshToken).toBe('rtok');
+    });
+
+    it('should leave oauth2 fields undefined when partially set', () => {
+      const config = loadConfig({ GOOGLE_CLIENT_ID: 'cid' });
+      expect(config.oauth2.clientId).toBe('cid');
+      expect(config.oauth2.clientSecret).toBeUndefined();
+      expect(config.oauth2.refreshToken).toBeUndefined();
+    });
+  });
+
+  describe('logging', () => {
+    it('should read LOG_LEVEL from env', () => {
+      const config = loadConfig({ LOG_LEVEL: 'debug' });
+      expect(config.logging.level).toBe('debug');
+    });
+  });
+});

package/src/config.ts

@@ -0,0 +1,33 @@
+// MCP server configuration for Blogger
+export const config = {
+  // Server operating mode (stdio or http)
+  mode: process.env.MCP_MODE || 'stdio',
+  
+  // HTTP mode configuration (if used)
+  http: {
+    host: process.env.MCP_HTTP_HOST || '0.0.0.0',
+    port: parseInt(process.env.MCP_HTTP_PORT || '3000', 10)
+  },
+  
+  // Blogger API configuration
+  blogger: {
+    apiKey: process.env.BLOGGER_API_KEY,
+    // Default maximum number of results for list queries
+    maxResults: parseInt(process.env.BLOGGER_MAX_RESULTS || '10', 10),
+    // API request timeout in milliseconds
+    timeout: parseInt(process.env.BLOGGER_API_TIMEOUT || '30000', 10)
+  },
+  
+  // OAuth2 configuration for authenticated operations (create, update, delete)
+  // If these variables are not set, the server runs in read-only mode (API key)
+  oauth2: {
+    clientId: process.env.GOOGLE_CLIENT_ID,
+    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+    refreshToken: process.env.GOOGLE_REFRESH_TOKEN
+  },
+  
+  // Logging configuration
+  logging: {
+    level: process.env.LOG_LEVEL || 'info'
+  }
+};