reddit-mcp-server 1.0.0

package/src/index.ts

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js"
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js"
+import { initializeRedditClient } from "./client/reddit-client"
+import * as tools from "./tools"
+import dotenv from "dotenv"
+
+// Load environment variables
+dotenv.config()
+
+class RedditServer {
+  private server: Server
+
+  constructor() {
+    console.log("[Setup] Initializing Reddit Server...")
+
+    // Initialize the Reddit client
+    this.initializeRedditClient()
+
+    this.server = new Server(
+      {
+        name: "reddit-mcp-server",
+        version: "0.1.0",
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    )
+
+    this.setupToolHandlers()
+
+    this.server.onerror = (error) => console.error("[Error] Server error:", error)
+    process.on("SIGINT", async () => {
+      await this.server.close()
+      process.exit(0)
+    })
+  }
+
+  private initializeRedditClient() {
+    const clientId = process.env.REDDIT_CLIENT_ID
+    const clientSecret = process.env.REDDIT_CLIENT_SECRET
+    const userAgent = process.env.REDDIT_USER_AGENT || "RedditMCPServer/0.1.0"
+    const username = process.env.REDDIT_USERNAME
+    const password = process.env.REDDIT_PASSWORD
+
+    if (!clientId || !clientSecret) {
+      console.error(
+        "[Error] Missing required Reddit API credentials. Please set REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET environment variables.",
+      )
+      process.exit(1)
+    }
+
+    try {
+      initializeRedditClient({
+        clientId,
+        clientSecret,
+        userAgent,
+        username,
+        password,
+      })
+
+      console.log("[Setup] Reddit client initialized")
+      if (username && password) {
+        console.log(`[Setup] Authenticated as user: ${username}`)
+      } else {
+        console.log("[Setup] Running in read-only mode (no user authentication)")
+      }
+    } catch (error) {
+      console.error("[Error] Failed to initialize Reddit client:", error)
+      process.exit(1)
+    }
+  }
+
+  private setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "test_reddit_mcp_server",
+          description: "Test the Reddit MCP Server",
+          inputSchema: {
+            type: "object",
+            properties: {
+              // No input parameters, this will just return a test message
+            },
+          },
+        },
+        {
+          name: "get_reddit_post",
+          description: "Get a Reddit post",
+          inputSchema: {
+            type: "object",
+            properties: {
+              subreddit: {
+                type: "string",
+                description: "The subreddit to fetch posts from",
+              },
+              post_id: {
+                type: "string",
+                description: "The ID of the post to fetch",
+              },
+            },
+            required: ["subreddit", "post_id"],
+          },
+        },
+        {
+          name: "get_top_posts",
+          description: "Get top posts from a subreddit",
+          inputSchema: {
+            type: "object",
+            properties: {
+              subreddit: {
+                type: "string",
+                description: "Name of the subreddit",
+              },
+              time_filter: {
+                type: "string",
+                description: "Time period to filter posts (e.g. 'day', 'week', 'month', 'year', 'all')",
+                enum: ["day", "week", "month", "year", "all"],
+                default: "week",
+              },
+              limit: {
+                type: "integer",
+                description: "Number of posts to fetch",
+                default: 10,
+              },
+            },
+            required: ["subreddit"],
+          },
+        },
+        {
+          name: "get_user_info",
+          description: "Get information about a Reddit user",
+          inputSchema: {
+            type: "object",
+            properties: {
+              username: {
+                type: "string",
+                description: "The username of the Reddit user to get info for",
+              },
+            },
+            required: ["username"],
+          },
+        },
+        {
+          name: "get_subreddit_info",
+          description: "Get information about a subreddit",
+          inputSchema: {
+            type: "object",
+            properties: {
+              subreddit_name: {
+                type: "string",
+                description: "Name of the subreddit",
+              },
+            },
+            required: ["subreddit_name"],
+          },
+        },
+        {
+          name: "get_trending_subreddits",
+          description: "Get currently trending subreddits",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
+        },
+        {
+          name: "create_post",
+          description: "Create a new post in a subreddit",
+          inputSchema: {
+            type: "object",
+            properties: {
+              subreddit: {
+                type: "string",
+                description: "Name of the subreddit to post in",
+              },
+              title: {
+                type: "string",
+                description: "Title of the post",
+              },
+              content: {
+                type: "string",
+                description: "Content of the post (text for self posts, URL for link posts)",
+              },
+              is_self: {
+                type: "boolean",
+                description: "Whether this is a self (text) post (true) or link post (false)",
+                default: true,
+              },
+            },
+            required: ["subreddit", "title", "content"],
+          },
+        },
+        {
+          name: "reply_to_post",
+          description: "Post a reply to an existing Reddit post",
+          inputSchema: {
+            type: "object",
+            properties: {
+              post_id: {
+                type: "string",
+                description: "The ID of the post to reply to",
+              },
+              content: {
+                type: "string",
+                description: "The content of the reply",
+              },
+              subreddit: {
+                type: "string",
+                description: "The subreddit name if known (for validation)",
+              },
+            },
+            required: ["post_id", "content"],
+          },
+        },
+      ],
+    }))
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        const toolName = request.params.name
+        const toolParams = request.params.arguments || {}
+
+        console.log(`[Request] Tool call: ${toolName}`, toolParams)
+
+        switch (toolName) {
+          case "test_reddit_mcp_server":
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Hello, world! The Reddit MCP Server is working correctly.",
+                },
+              ],
+            }
+
+          case "get_reddit_post":
+            return await tools.getRedditPost(toolParams as { subreddit: string; post_id: string })
+
+          case "get_top_posts":
+            return await tools.getTopPosts(
+              toolParams as {
+                subreddit: string
+                time_filter?: string
+                limit?: number
+              },
+            )
+
+          case "get_user_info":
+            return await tools.getUserInfo(toolParams as { username: string })
+
+          case "get_subreddit_info":
+            return await tools.getSubredditInfo(toolParams as { subreddit_name: string })
+
+          case "get_trending_subreddits":
+            return await tools.getTrendingSubreddits()
+
+          case "create_post":
+            return await tools.createPost(
+              toolParams as {
+                subreddit: string
+                title: string
+                content: string
+                is_self?: boolean
+              },
+            )
+
+          case "reply_to_post":
+            return await tools.replyToPost(
+              toolParams as {
+                post_id: string
+                content: string
+                subreddit?: string
+              },
+            )
+
+          default:
+            throw new McpError(ErrorCode.MethodNotFound, `Tool with name ${toolName} not found`)
+        }
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          console.error("[Error] Error calling tool:", error.message)
+
+          throw new McpError(ErrorCode.InternalError, `Failed to fetch data: ${error.message}`)
+        }
+
+        throw error
+      }
+    })
+  }
+
+  async run() {
+    const transport = new StdioServerTransport()
+    await this.server.connect(transport)
+    console.log("[Server] Server is running")
+  }
+}
+
+const server = new RedditServer()
+server.run().catch(console.error)

package/src/tools/index.ts

@@ -0,0 +1,3 @@
+export * from "./user-tools"
+export * from "./post-tools"
+export * from "./subreddit-tools"

package/src/tools/post-tools.ts

@@ -0,0 +1,178 @@
+import { getRedditClient } from "../client/reddit-client"
+import { formatPostInfo, formatCommentInfo } from "../utils/formatters"
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
+
+export async function getRedditPost(params: { subreddit: string; post_id: string }) {
+  const { subreddit, post_id } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log(`[Tool] Getting post ${post_id} from r/${subreddit}`)
+    const post = await client.getPost(post_id, subreddit)
+    const formattedPost = formatPostInfo(post)
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Post from r/${formattedPost.subreddit}
+
+## Post Details
+- Title: ${formattedPost.title}
+- Type: ${formattedPost.type}
+- Author: u/${formattedPost.author}
+
+## Content
+${formattedPost.content}
+
+## Stats
+- Score: ${formattedPost.stats.score.toLocaleString()}
+- Upvote Ratio: ${(formattedPost.stats.upvoteRatio * 100).toFixed(1)}%
+- Comments: ${formattedPost.stats.comments.toLocaleString()}
+
+## Metadata
+- Posted: ${formattedPost.metadata.posted}
+- Flags: ${formattedPost.metadata.flags.length ? formattedPost.metadata.flags.join(", ") : "None"}
+- Flair: ${formattedPost.metadata.flair}
+
+## Links
+- Full Post: ${formattedPost.links.fullPost}
+- Short Link: ${formattedPost.links.shortLink}
+
+## Engagement Analysis
+- ${formattedPost.engagementAnalysis.replace(/\n  - /g, "\n- ")}
+
+## Best Time to Engage
+${formattedPost.bestTimeToEngage}
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error getting post: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch post data: ${error}`)
+  }
+}
+
+export async function getTopPosts(params: { subreddit: string; time_filter?: string; limit?: number }) {
+  const { subreddit, time_filter = "week", limit = 10 } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log(`[Tool] Getting top posts from r/${subreddit}`)
+    const posts = await client.getTopPosts(subreddit, time_filter, limit)
+    const formattedPosts = posts.map(formatPostInfo)
+
+    const postSummaries = formattedPosts
+      .map(
+        (post, index) => `
+### ${index + 1}. ${post.title}
+- Author: u/${post.author}
+- Score: ${post.stats.score.toLocaleString()} (${(post.stats.upvoteRatio * 100).toFixed(1)}% upvoted)
+- Comments: ${post.stats.comments.toLocaleString()}
+- Posted: ${post.metadata.posted}
+- Link: ${post.links.shortLink}
+    `,
+      )
+      .join("\n")
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Top Posts from r/${subreddit} (${time_filter})
+
+${postSummaries}
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error getting top posts: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch top posts: ${error}`)
+  }
+}
+
+export async function createPost(params: { subreddit: string; title: string; content: string; is_self?: boolean }) {
+  const { subreddit, title, content, is_self = true } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log(`[Tool] Creating ${is_self ? "text" : "link"} post in r/${subreddit}`)
+    const post = await client.createPost(subreddit, title, content, is_self)
+    const formattedPost = formatPostInfo(post)
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Post Created Successfully
+
+## Post Details
+- Title: ${formattedPost.title}
+- Subreddit: r/${formattedPost.subreddit}
+- Type: ${formattedPost.type}
+- Link: ${formattedPost.links.fullPost}
+
+Your post has been successfully submitted to r/${formattedPost.subreddit}.
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error creating post: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to create post: ${error}`)
+  }
+}
+
+export async function replyToPost(params: { post_id: string; content: string; subreddit?: string }) {
+  const { post_id, content } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log(`[Tool] Replying to post ${post_id}`)
+    const comment = await client.replyToPost(post_id, content)
+    const formattedComment = formatCommentInfo(comment)
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Reply Posted Successfully
+
+## Comment Details
+- Author: u/${formattedComment.author}
+- Subreddit: r/${formattedComment.context.subreddit}
+- Thread: ${formattedComment.context.thread}
+- Link: ${formattedComment.link}
+
+Your reply has been successfully posted.
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error replying to post: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to reply to post: ${error}`)
+  }
+}

package/src/tools/subreddit-tools.ts

@@ -0,0 +1,91 @@
+import { getRedditClient } from "../client/reddit-client"
+import { formatSubredditInfo } from "../utils/formatters"
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
+
+export async function getSubredditInfo(params: { subreddit_name: string }) {
+  const { subreddit_name } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log(`[Tool] Getting info for r/${subreddit_name}`)
+    const subreddit = await client.getSubredditInfo(subreddit_name)
+    const formattedSubreddit = formatSubredditInfo(subreddit)
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Subreddit Information: r/${formattedSubreddit.name}
+
+## Overview
+- Name: r/${formattedSubreddit.name}
+- Title: ${formattedSubreddit.title}
+- Subscribers: ${formattedSubreddit.stats.subscribers.toLocaleString()}
+- Active Users: ${
+            typeof formattedSubreddit.stats.activeUsers === "number"
+              ? formattedSubreddit.stats.activeUsers.toLocaleString()
+              : formattedSubreddit.stats.activeUsers
+          }
+
+## Description
+${formattedSubreddit.description.short}
+
+## Detailed Description
+${formattedSubreddit.description.full}
+
+## Metadata
+- Created: ${formattedSubreddit.metadata.created}
+- Flags: ${formattedSubreddit.metadata.flags.join(", ")}
+
+## Links
+- Subreddit: ${formattedSubreddit.links.subreddit}
+- Wiki: ${formattedSubreddit.links.wiki}
+
+## Community Analysis
+- ${formattedSubreddit.communityAnalysis.replace(/\n  - /g, "\n- ")}
+
+## Engagement Tips
+- ${formattedSubreddit.engagementTips.replace(/\n  - /g, "\n- ")}
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error getting subreddit info: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch subreddit data: ${error}`)
+  }
+}
+
+export async function getTrendingSubreddits() {
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log("[Tool] Getting trending subreddits")
+    const trendingSubreddits = await client.getTrendingSubreddits()
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Trending Subreddits
+
+${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error getting trending subreddits: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch trending subreddits: ${error}`)
+  }
+}

package/src/tools/user-tools.ts

@@ -0,0 +1,48 @@
+import { getRedditClient } from "../client/reddit-client"
+import { formatUserInfo } from "../utils/formatters"
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
+
+export async function getUserInfo(params: { username: string }) {
+  const { username } = params
+  const client = getRedditClient()
+
+  if (!client) {
+    throw new McpError(ErrorCode.InternalError, "Reddit client not initialized")
+  }
+
+  try {
+    console.log(`[Tool] Getting info for u/${username}`)
+    const user = await client.getUser(username)
+    const formattedUser = formatUserInfo(user)
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# User Information: u/${formattedUser.username}
+
+## Profile Overview
+- Username: u/${formattedUser.username}
+- Karma:
+  - Comment Karma: ${formattedUser.karma.commentKarma.toLocaleString()}
+  - Post Karma: ${formattedUser.karma.postKarma.toLocaleString()}
+  - Total Karma: ${formattedUser.karma.totalKarma.toLocaleString()}
+- Account Status: ${formattedUser.accountStatus.join(", ")}
+- Account Created: ${formattedUser.accountCreated}
+- Profile URL: ${formattedUser.profileUrl}
+
+## Activity Analysis
+- ${formattedUser.activityAnalysis.replace(/\n  - /g, "\n- ")}
+
+## Recommendations
+- ${formattedUser.recommendations.replace(/\n  - /g, "\n- ")}
+          `,
+        },
+      ],
+    }
+  } catch (error) {
+    console.error(`[Error] Error getting user info: ${error}`)
+    throw new McpError(ErrorCode.InternalError, `Failed to fetch user data: ${error}`)
+  }
+}