reddit-mcp-server 1.0.3 → 1.0.4

package/dist/bin.js

@@ -0,0 +1,1098 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types4 = require("@modelcontextprotocol/sdk/types.js");
+
+// src/client/reddit-client.ts
+var import_axios = __toESM(require("axios"));
+var RedditClient = class {
+  clientId;
+  clientSecret;
+  userAgent;
+  username;
+  password;
+  accessToken;
+  tokenExpiry = 0;
+  api;
+  authenticated = false;
+  constructor(config) {
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
+    this.userAgent = config.userAgent;
+    this.username = config.username;
+    this.password = config.password;
+    this.api = import_axios.default.create({
+      baseURL: "https://oauth.reddit.com",
+      headers: {
+        "User-Agent": this.userAgent
+      }
+    });
+    this.api.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        if (error.response?.status === 401 && this.authenticated) {
+          await this.authenticate();
+          const originalRequest = error.config;
+          originalRequest.headers["Authorization"] = `Bearer ${this.accessToken}`;
+          return this.api(originalRequest);
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+  async authenticate() {
+    try {
+      const now = Date.now();
+      if (this.accessToken && now < this.tokenExpiry) {
+        return;
+      }
+      const authUrl = "https://www.reddit.com/api/v1/access_token";
+      const authData = new URLSearchParams();
+      if (this.username && this.password) {
+        authData.append("grant_type", "password");
+        authData.append("username", this.username);
+        authData.append("password", this.password);
+      } else {
+        authData.append("grant_type", "client_credentials");
+      }
+      const response = await import_axios.default.post(authUrl, authData, {
+        auth: {
+          username: this.clientId,
+          password: this.clientSecret
+        },
+        headers: {
+          "User-Agent": this.userAgent,
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      this.accessToken = response.data.access_token;
+      this.tokenExpiry = now + response.data.expires_in * 1e3;
+      this.authenticated = true;
+      this.api.defaults.headers.common["Authorization"] = `Bearer ${this.accessToken}`;
+    } catch {
+      throw new Error("Failed to authenticate with Reddit API");
+    }
+  }
+  async checkAuthentication() {
+    if (!this.authenticated) {
+      try {
+        await this.authenticate();
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+  async getUser(username) {
+    await this.authenticate();
+    try {
+      const response = await this.api.get(`/user/${username}/about.json`);
+      const data = response.data.data;
+      return {
+        name: data.name,
+        id: data.id,
+        commentKarma: data.comment_karma,
+        linkKarma: data.link_karma,
+        totalKarma: data.total_karma || data.comment_karma + data.link_karma,
+        isMod: data.is_mod,
+        isGold: data.is_gold,
+        isEmployee: data.is_employee,
+        createdUtc: data.created_utc,
+        profileUrl: `https://reddit.com/user/${data.name}`
+      };
+    } catch {
+      throw new Error(`Failed to get user info for ${username}`);
+    }
+  }
+  async getSubredditInfo(subredditName) {
+    await this.authenticate();
+    try {
+      const response = await this.api.get(`/r/${subredditName}/about.json`);
+      const data = response.data.data;
+      return {
+        displayName: data.display_name,
+        title: data.title,
+        description: data.description || "",
+        publicDescription: data.public_description || "",
+        subscribers: data.subscribers,
+        activeUserCount: data.active_user_count,
+        createdUtc: data.created_utc,
+        over18: data.over18,
+        subredditType: data.subreddit_type,
+        url: data.url
+      };
+    } catch {
+      throw new Error(`Failed to get subreddit info for ${subredditName}`);
+    }
+  }
+  async getTopPosts(subreddit, timeFilter = "week", limit = 10) {
+    await this.authenticate();
+    try {
+      const endpoint = subreddit ? `/r/${subreddit}/top.json` : "/top.json";
+      const response = await this.api.get(endpoint, {
+        params: {
+          t: timeFilter,
+          limit
+        }
+      });
+      return response.data.data.children.map((child) => {
+        const post = child.data;
+        return {
+          id: post.id,
+          title: post.title,
+          author: post.author,
+          subreddit: post.subreddit,
+          selftext: post.selftext,
+          url: post.url,
+          score: post.score,
+          upvoteRatio: post.upvote_ratio,
+          numComments: post.num_comments,
+          createdUtc: post.created_utc,
+          over18: post.over_18,
+          spoiler: post.spoiler,
+          edited: !!post.edited,
+          isSelf: post.is_self,
+          linkFlairText: post.link_flair_text,
+          permalink: post.permalink
+        };
+      });
+    } catch {
+      throw new Error(`Failed to get top posts for ${subreddit || "home"}`);
+    }
+  }
+  async getPost(postId, subreddit) {
+    await this.authenticate();
+    try {
+      const endpoint = subreddit ? `/r/${subreddit}/comments/${postId}.json` : `/api/info.json?id=t3_${postId}`;
+      const response = await this.api.get(endpoint);
+      let post;
+      if (subreddit) {
+        post = response.data[0].data.children[0].data;
+      } else {
+        if (!response.data.data.children.length) {
+          throw new Error(`Post with ID ${postId} not found`);
+        }
+        post = response.data.data.children[0].data;
+      }
+      return {
+        id: post.id,
+        title: post.title,
+        author: post.author,
+        subreddit: post.subreddit,
+        selftext: post.selftext,
+        url: post.url,
+        score: post.score,
+        upvoteRatio: post.upvote_ratio,
+        numComments: post.num_comments,
+        createdUtc: post.created_utc,
+        over18: post.over_18,
+        spoiler: post.spoiler,
+        edited: !!post.edited,
+        isSelf: post.is_self,
+        linkFlairText: post.link_flair_text,
+        permalink: post.permalink
+      };
+    } catch {
+      throw new Error(`Failed to get post with ID ${postId}`);
+    }
+  }
+  async getTrendingSubreddits(limit = 5) {
+    await this.authenticate();
+    try {
+      const response = await this.api.get("/subreddits/popular.json", {
+        params: { limit }
+      });
+      return response.data.data.children.map((child) => child.data.display_name);
+    } catch {
+      throw new Error("Failed to get trending subreddits");
+    }
+  }
+  async createPost(subreddit, title, content, isSelf = true) {
+    await this.authenticate();
+    if (!this.username || !this.password) {
+      throw new Error("User authentication required for posting");
+    }
+    try {
+      const kind = isSelf ? "self" : "link";
+      const params = new URLSearchParams();
+      params.append("sr", subreddit);
+      params.append("kind", kind);
+      params.append("title", title);
+      params.append(isSelf ? "text" : "url", content);
+      const response = await this.api.post("/api/submit", params, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      if (response.data.success) {
+        const postId = response.data.data.id;
+        return await this.getPost(postId);
+      } else {
+        throw new Error("Failed to create post");
+      }
+    } catch {
+      throw new Error(`Failed to create post in ${subreddit}`);
+    }
+  }
+  async checkPostExists(postId) {
+    await this.authenticate();
+    try {
+      const response = await this.api.get(`/api/info.json?id=t3_${postId}`);
+      return response.data.data.children.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async replyToPost(postId, content) {
+    await this.authenticate();
+    if (!this.username || !this.password) {
+      throw new Error("User authentication required for posting replies");
+    }
+    try {
+      if (!await this.checkPostExists(postId)) {
+        throw new Error(`Post with ID ${postId} does not exist or is not accessible`);
+      }
+      const params = new URLSearchParams();
+      params.append("thing_id", `t3_${postId}`);
+      params.append("text", content);
+      const response = await this.api.post("/api/comment", params, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      const commentData = response.data;
+      return {
+        id: commentData.id,
+        author: this.username,
+        body: content,
+        score: 1,
+        controversiality: 0,
+        subreddit: commentData.subreddit,
+        submissionTitle: commentData.link_title,
+        createdUtc: Date.now() / 1e3,
+        edited: false,
+        isSubmitter: false,
+        permalink: commentData.permalink
+      };
+    } catch {
+      throw new Error(`Failed to reply to post ${postId}`);
+    }
+  }
+};
+var redditClient = null;
+function initializeRedditClient(config) {
+  redditClient = new RedditClient(config);
+  return redditClient;
+}
+function getRedditClient() {
+  return redditClient;
+}
+
+// src/utils/formatters.ts
+function formatTimestamp(timestamp) {
+  try {
+    const date = new Date(timestamp * 1e3);
+    return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
+  } catch {
+    return String(timestamp);
+  }
+}
+function analyzeUserActivity(karmaRatio, isMod, accountAgeDays) {
+  const insights = [];
+  if (karmaRatio > 5) {
+    insights.push("Primarily a commenter, highly engaged in discussions");
+  } else if (karmaRatio < 0.2) {
+    insights.push("Content creator, focuses on sharing posts");
+  } else {
+    insights.push("Balanced participation in both posting and commenting");
+  }
+  if (accountAgeDays < 30) {
+    insights.push("New user, still exploring Reddit");
+  } else if (accountAgeDays > 365 * 5) {
+    insights.push("Long-time Redditor with extensive platform experience");
+  }
+  if (isMod) {
+    insights.push("Community leader who helps maintain subreddit quality");
+  }
+  return insights.join("\n  - ");
+}
+function analyzePostEngagement(score, ratio, numComments) {
+  const insights = [];
+  if (score > 1e3 && ratio > 0.95) {
+    insights.push("Highly successful post with strong community approval");
+  } else if (score > 100 && ratio > 0.8) {
+    insights.push("Well-received post with good engagement");
+  } else if (ratio < 0.5) {
+    insights.push("Controversial post that sparked debate");
+  }
+  if (numComments > 100) {
+    insights.push("Generated significant discussion");
+  } else if (numComments > score * 0.5) {
+    insights.push("Highly discussable content with active comment section");
+  } else if (numComments === 0) {
+    insights.push("Yet to receive community interaction");
+  }
+  return insights.join("\n  - ");
+}
+function analyzeSubredditHealth(subscribers, activeUsers, ageDays) {
+  const insights = [];
+  if (subscribers > 1e6) {
+    insights.push("Major subreddit with massive following");
+  } else if (subscribers > 1e5) {
+    insights.push("Well-established community");
+  } else if (subscribers < 1e3) {
+    insights.push("Niche community, potential for growth");
+  }
+  if (activeUsers) {
+    const activityRatio = activeUsers / subscribers;
+    if (activityRatio > 0.1) {
+      insights.push("Highly active community with strong engagement");
+    } else if (activityRatio < 0.01) {
+      insights.push("Could benefit from more community engagement initiatives");
+    }
+  }
+  if (ageDays > 365 * 5) {
+    insights.push("Mature subreddit with established culture");
+  } else if (ageDays < 90) {
+    insights.push("New subreddit still forming its community");
+  }
+  return insights.join("\n  - ");
+}
+function getUserRecommendations(karmaRatio, isMod, accountAgeDays) {
+  const recommendations = [];
+  if (karmaRatio > 5) {
+    recommendations.push("Consider creating more posts to share your expertise");
+  } else if (karmaRatio < 0.2) {
+    recommendations.push("Engage more in discussions to build community connections");
+  }
+  if (accountAgeDays < 30) {
+    recommendations.push("Explore popular subreddits in your areas of interest");
+    recommendations.push("Read community guidelines before posting");
+  }
+  if (isMod) {
+    recommendations.push("Share moderation insights with other community leaders");
+  }
+  if (!recommendations.length) {
+    recommendations.push("Maintain your balanced engagement across Reddit");
+  }
+  return recommendations.join("\n  - ");
+}
+function getBestEngagementTime(createdUtc) {
+  const postHour = new Date(createdUtc * 1e3).getHours();
+  if (14 <= postHour && postHour <= 18) {
+    return "Posted during peak engagement hours (2 PM - 6 PM), good timing!";
+  } else if (23 <= postHour || postHour <= 5) {
+    return "Consider posting during more active hours (morning to evening)";
+  } else {
+    return "Posted during moderate activity hours, timing could be optimized";
+  }
+}
+function getSubredditEngagementTips(subreddit) {
+  const tips = [];
+  if (subreddit.subscribers > 1e6) {
+    tips.push("Post during peak hours for maximum visibility");
+    tips.push("Ensure content is highly polished due to high competition");
+  } else if (subreddit.subscribers < 1e3) {
+    tips.push("Engage actively to help grow the community");
+    tips.push("Consider cross-posting to related larger subreddits");
+  }
+  if (subreddit.activeUserCount) {
+    const activityRatio = subreddit.activeUserCount / subreddit.subscribers;
+    if (activityRatio > 0.1) {
+      tips.push("Quick responses recommended due to high activity");
+    }
+  }
+  return tips.length ? tips.join("\n  - ") : "Regular engagement recommended to maintain community presence";
+}
+function analyzeCommentImpact(score, isEdited, isOp) {
+  const insights = [];
+  if (score > 100) {
+    insights.push("Highly upvoted comment with significant community agreement");
+  } else if (score < 0) {
+    insights.push("Controversial or contested viewpoint");
+  }
+  if (isEdited) {
+    insights.push("Refined for clarity or accuracy");
+  }
+  if (isOp) {
+    insights.push("Author's perspective adds context to original post");
+  }
+  return insights.length ? insights.join("\n  - ") : "Standard engagement with discussion";
+}
+function formatUserInfo(user) {
+  const status = [];
+  if (user.isMod) status.push("Moderator");
+  if (user.isGold) status.push("Reddit Gold Member");
+  if (user.isEmployee) status.push("Reddit Employee");
+  const accountAgeDays = (Date.now() / 1e3 - user.createdUtc) / (24 * 3600);
+  const karmaRatio = user.commentKarma / (user.linkKarma || 1);
+  return {
+    username: user.name,
+    karma: {
+      commentKarma: user.commentKarma,
+      postKarma: user.linkKarma,
+      totalKarma: user.totalKarma
+    },
+    accountStatus: status.length ? status : ["Regular User"],
+    accountCreated: formatTimestamp(user.createdUtc),
+    profileUrl: user.profileUrl,
+    activityAnalysis: analyzeUserActivity(karmaRatio, user.isMod, accountAgeDays),
+    recommendations: getUserRecommendations(karmaRatio, user.isMod, accountAgeDays)
+  };
+}
+function formatPostInfo(post) {
+  const contentType = post.isSelf ? "Text Post" : "Link Post";
+  const content = post.isSelf ? post.selftext || "" : post.url || "";
+  const flags = [];
+  if (post.over18) flags.push("NSFW");
+  if (post.spoiler) flags.push("Spoiler");
+  if (post.edited) flags.push("Edited");
+  return {
+    title: post.title,
+    type: contentType,
+    content: content.length > 300 ? content.substring(0, 297) + "..." : content,
+    author: post.author,
+    subreddit: post.subreddit,
+    stats: {
+      score: post.score,
+      upvoteRatio: post.upvoteRatio,
+      comments: post.numComments
+    },
+    metadata: {
+      posted: formatTimestamp(post.createdUtc),
+      flags,
+      flair: post.linkFlairText || "None"
+    },
+    links: {
+      fullPost: `https://reddit.com${post.permalink}`,
+      shortLink: `https://redd.it/${post.id}`
+    },
+    engagementAnalysis: analyzePostEngagement(post.score, post.upvoteRatio, post.numComments),
+    bestTimeToEngage: getBestEngagementTime(post.createdUtc)
+  };
+}
+function formatSubredditInfo(subreddit) {
+  const flags = [];
+  if (subreddit.over18) flags.push("NSFW");
+  if (subreddit.subredditType) flags.push(`Type: ${subreddit.subredditType}`);
+  const ageDays = (Date.now() / 1e3 - subreddit.createdUtc) / (24 * 3600);
+  return {
+    name: subreddit.displayName,
+    title: subreddit.title,
+    stats: {
+      subscribers: subreddit.subscribers,
+      activeUsers: subreddit.activeUserCount !== void 0 ? subreddit.activeUserCount : "Unknown"
+    },
+    description: {
+      short: subreddit.publicDescription,
+      full: subreddit.description.length > 300 ? subreddit.description.substring(0, 297) + "..." : subreddit.description
+    },
+    metadata: {
+      created: formatTimestamp(subreddit.createdUtc),
+      flags: flags.length ? flags : ["None"]
+    },
+    links: {
+      subreddit: `https://reddit.com${subreddit.url}`,
+      wiki: `https://reddit.com/r/${subreddit.displayName}/wiki`
+    },
+    communityAnalysis: analyzeSubredditHealth(subreddit.subscribers, subreddit.activeUserCount, ageDays),
+    engagementTips: getSubredditEngagementTips(subreddit)
+  };
+}
+function formatCommentInfo(comment) {
+  const flags = [];
+  if (comment.edited) flags.push("Edited");
+  if (comment.isSubmitter) flags.push("OP");
+  return {
+    author: comment.author,
+    content: comment.body.length > 300 ? comment.body.substring(0, 297) + "..." : comment.body,
+    stats: {
+      score: comment.score,
+      controversiality: comment.controversiality
+    },
+    context: {
+      subreddit: comment.subreddit,
+      thread: comment.submissionTitle
+    },
+    metadata: {
+      posted: formatTimestamp(comment.createdUtc),
+      flags: flags.length ? flags : ["None"]
+    },
+    link: `https://reddit.com${comment.permalink}`,
+    commentAnalysis: analyzeCommentImpact(comment.score, comment.edited, comment.isSubmitter)
+  };
+}
+
+// src/tools/user-tools.ts
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+async function getUserInfo(params) {
+  const { username } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    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) {
+    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user data: ${String(error)}`);
+  }
+}
+
+// src/tools/post-tools.ts
+var import_types2 = require("@modelcontextprotocol/sdk/types.js");
+async function getRedditPost(params) {
+  const { subreddit, post_id } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    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) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to fetch post data: ${String(error)}`);
+  }
+}
+async function getTopPosts(params) {
+  const { subreddit, time_filter = "week", limit = 10 } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    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) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to fetch top posts: ${String(error)}`);
+  }
+}
+async function createPost(params) {
+  const { subreddit, title, content, is_self = true } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    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) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to create post: ${String(error)}`);
+  }
+}
+async function replyToPost(params) {
+  const { post_id, content } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    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) {
+    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to reply to post: ${String(error)}`);
+  }
+}
+
+// src/tools/subreddit-tools.ts
+var import_types3 = require("@modelcontextprotocol/sdk/types.js");
+async function getSubredditInfo(params) {
+  const { subreddit_name } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    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) {
+    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, `Failed to fetch subreddit data: ${String(error)}`);
+  }
+}
+async function getTrendingSubreddits() {
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    const trendingSubreddits = await client.getTrendingSubreddits();
+    return {
+      content: [
+        {
+          type: "text",
+          text: `
+# Trending Subreddits
+
+${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}
+          `
+        }
+      ]
+    };
+  } catch (error) {
+    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, `Failed to fetch trending subreddits: ${String(error)}`);
+  }
+}
+
+// src/index.ts
+var import_dotenv = __toESM(require("dotenv"));
+import_dotenv.default.config();
+var RedditServer = class {
+  server;
+  constructor() {
+    this.server = new import_server.Server(
+      {
+        name: "reddit-mcp-server",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.initializeRedditClient();
+    this.setupToolHandlers();
+    this.server.onerror = async (error) => {
+      await this.server.sendLoggingMessage({
+        level: "error",
+        logger: "reddit-server",
+        data: `Server error: ${error}`
+      });
+    };
+    process.on("SIGINT", async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+  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
+      });
+    } catch (error) {
+      console.error("[Error] Failed to initialize Reddit client:", error);
+      process.exit(1);
+    }
+  }
+  setupToolHandlers() {
+    this.server.setRequestHandler(import_types4.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(import_types4.CallToolRequestSchema, async (request) => {
+      try {
+        const toolName = request.params.name;
+        const toolParams = request.params.arguments || {};
+        await this.server.sendLoggingMessage({
+          level: "debug",
+          logger: "reddit-server",
+          data: `Tool call: ${toolName}`
+        });
+        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 getRedditPost(toolParams);
+          case "get_top_posts":
+            return await getTopPosts(
+              toolParams
+            );
+          case "get_user_info":
+            return await getUserInfo(toolParams);
+          case "get_subreddit_info":
+            return await getSubredditInfo(toolParams);
+          case "get_trending_subreddits":
+            return await getTrendingSubreddits();
+          case "create_post":
+            return await createPost(
+              toolParams
+            );
+          case "reply_to_post":
+            return await replyToPost(
+              toolParams
+            );
+          default:
+            throw new import_types4.McpError(import_types4.ErrorCode.MethodNotFound, `Tool with name ${toolName} not found`);
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          await this.server.sendLoggingMessage({
+            level: "error",
+            logger: "reddit-server",
+            data: `Error calling tool: ${error.message}`
+          });
+          throw new import_types4.McpError(import_types4.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+        }
+        throw error;
+      }
+    });
+  }
+  async run() {
+    const transport = new import_stdio.StdioServerTransport();
+    await this.server.connect(transport);
+    await this.server.sendLoggingMessage({
+      level: "info",
+      logger: "reddit-server",
+      data: "Reddit MCP Server is running"
+    });
+    const username = process.env.REDDIT_USERNAME;
+    const password = process.env.REDDIT_PASSWORD;
+    await this.server.sendLoggingMessage({
+      level: "info",
+      logger: "reddit-server",
+      data: username && password ? `Authenticated as user: ${username}` : "Running in read-only mode (no user authentication)"
+    });
+  }
+};
+if (require.main === module) {
+  const server2 = new RedditServer();
+  server2.run().catch(console.error);
+}
+
+// src/bin.ts
+var server = new RedditServer();
+server.run().catch(console.error);