@dalcontak/blogger-mcp-server 1.0.0 → 1.0.2

package/src/bloggerService.ts

@@ -1,33 +1,16 @@
 import { google, blogger_v3 } from 'googleapis';
-import { BloggerBlog, BloggerPost, BloggerLabel } from './types';
+import { BloggerPost } from './types';
 import { config } from './config';
 
-/**
- * Custom types to compensate for Blogger API limitations
- */
 interface BloggerLabelList {
   kind?: string;
-  items?: BloggerLabel[];
+  items?: Array<{ name: string }>;
 }
 
-/**
- * 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);
@@ -63,10 +46,6 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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(
@@ -77,11 +56,6 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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 {
@@ -95,16 +69,9 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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
-      });
+      const response = await this.blogger.blogs.get({ blogId });
       return response.data;
     } catch (error) {
       console.error(`Error fetching blog ${blogId}:`, error);
@@ -112,16 +79,9 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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
-      });
+      const response = await this.blogger.blogs.getByUrl({ url });
       return response.data;
     } catch (error) {
       console.error(`Error fetching blog by URL ${url}:`, error);
@@ -129,33 +89,6 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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({
@@ -169,13 +102,6 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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({
@@ -184,8 +110,6 @@ export class BloggerService {
         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;
 
@@ -199,18 +123,9 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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
-      });
+      const response = await this.blogger.posts.get({ blogId, postId });
       return response.data;
     } catch (error) {
       console.error(`Error fetching post ${postId}:`, error);
@@ -218,20 +133,15 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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
-      });
+      const requestBody: blogger_v3.Schema$Post = {
+        title: postData.title ?? undefined,
+        content: postData.content ?? undefined,
+        labels: postData.labels ?? undefined
+      };
+      const response = await this.blogger.posts.insert({ blogId, requestBody });
       return response.data;
     } catch (error) {
       console.error(`Error creating post in blog ${blogId}:`, error);
@@ -239,29 +149,15 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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
+        title: postData.title ?? undefined,
+        content: postData.content ?? undefined,
+        labels: postData.labels ?? undefined
       };
-      
-      const response = await this.blogger.posts.update({
-        blogId,
-        postId,
-        requestBody
-      });
+      const response = await this.blogger.posts.update({ blogId, postId, requestBody });
       return response.data;
     } catch (error) {
       console.error(`Error updating post ${postId}:`, error);
@@ -269,79 +165,48 @@ export class BloggerService {
     }
   }
 
-  /**
-   * 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
-      });
+      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
+        maxResults: 50
       });
-      
+
       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));
+        (post.labels || []).forEach(label => labelSet.add(label));
       });
-      
-      // Convert to expected format
+
       const labels = Array.from(labelSet).map(name => ({ name }));
-      
-      return {
-        kind: 'blogger#labelList',
-        items: labels
-      };
+
+      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> {
+  async getLabel(blogId: string, labelName: string): Promise<{ name: string }> {
     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);

package/src/config.test.ts

@@ -1,29 +1,18 @@
-/**
- * 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'
+    'LOG_LEVEL', 'UI_PORT'
   ];
   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
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let config: any;
   jest.isolateModules(() => {
     config = require('./config').config;
@@ -51,6 +40,7 @@ describe('config.ts', () => {
       expect(config.oauth2.clientSecret).toBeUndefined();
       expect(config.oauth2.refreshToken).toBeUndefined();
       expect(config.logging.level).toBe('info');
+      expect(config.ui.port).toBe(0);
     });
   });
 
@@ -59,11 +49,6 @@ describe('config.ts', () => {
       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', () => {
@@ -72,10 +57,22 @@ describe('config.ts', () => {
       expect(config.http.host).toBe('127.0.0.1');
       expect(config.http.port).toBe(8080);
     });
+  });
 
-    it('should return NaN for non-numeric port', () => {
+  describe('safeInt (NaN protection)', () => {
+    it('should return default for non-numeric port', () => {
       const config = loadConfig({ MCP_HTTP_PORT: 'abc' });
-      expect(config.http.port).toBeNaN();
+      expect(config.http.port).toBe(3000);
+    });
+
+    it('should return default for non-numeric maxResults', () => {
+      const config = loadConfig({ BLOGGER_MAX_RESULTS: 'notanumber' });
+      expect(config.blogger.maxResults).toBe(10);
+    });
+
+    it('should return default for non-numeric timeout', () => {
+      const config = loadConfig({ BLOGGER_API_TIMEOUT: 'xyz' });
+      expect(config.blogger.timeout).toBe(30000);
     });
   });
 
@@ -118,4 +115,21 @@ describe('config.ts', () => {
       expect(config.logging.level).toBe('debug');
     });
   });
+
+  describe('ui', () => {
+    it('should default to port 0 (disabled)', () => {
+      const config = loadConfig({});
+      expect(config.ui.port).toBe(0);
+    });
+
+    it('should read UI_PORT from env', () => {
+      const config = loadConfig({ UI_PORT: '4000' });
+      expect(config.ui.port).toBe(4000);
+    });
+
+    it('should return default 0 for non-numeric UI_PORT', () => {
+      const config = loadConfig({ UI_PORT: 'abc' });
+      expect(config.ui.port).toBe(0);
+    });
+  });
 });

package/src/config.ts

@@ -1,33 +1,34 @@
-// MCP server configuration for Blogger
+function safeInt(value: string | undefined, defaultValue: number): number {
+  if (!value) return defaultValue;
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? defaultValue : parsed;
+}
+
 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)
+    port: safeInt(process.env.MCP_HTTP_PORT, 3000)
   },
-  
-  // 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)
+    maxResults: safeInt(process.env.BLOGGER_MAX_RESULTS, 10),
+    timeout: safeInt(process.env.BLOGGER_API_TIMEOUT, 30000)
   },
-  
-  // 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'
+  },
+
+  ui: {
+    port: safeInt(process.env.UI_PORT, 0)
   }
 };