reddit-mcp-server 1.0.9 → 1.1.0

package/dist/server.js

@@ -0,0 +1,1754 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_hono = require("hono");
+var import_cors = require("hono/cors");
+var import_node_server = require("@hono/node-server");
+var import_mcp = require("@hono/mcp");
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_types6 = require("@modelcontextprotocol/sdk/types.js");
+
+// src/client/reddit-client.ts
+var RedditClient = class {
+  clientId;
+  clientSecret;
+  userAgent;
+  username;
+  password;
+  accessToken;
+  tokenExpiry = 0;
+  baseUrl = "https://oauth.reddit.com";
+  authenticated = false;
+  constructor(config) {
+    this.clientId = config.clientId;
+    this.clientSecret = config.clientSecret;
+    this.userAgent = config.userAgent;
+    this.username = config.username;
+    this.password = config.password;
+  }
+  async makeRequest(path, options = {}) {
+    if (Date.now() >= this.tokenExpiry || !this.authenticated) {
+      await this.authenticate();
+    }
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      "User-Agent": this.userAgent,
+      Authorization: `Bearer ${this.accessToken}`,
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (response.status === 401 && this.authenticated) {
+      await this.authenticate();
+      const retryHeaders = {
+        ...headers,
+        Authorization: `Bearer ${this.accessToken}`
+      };
+      return fetch(url, {
+        ...options,
+        headers: retryHeaders
+      });
+    }
+    return response;
+  }
+  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 credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
+      const response = await fetch(authUrl, {
+        method: "POST",
+        headers: {
+          "User-Agent": this.userAgent,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${credentials}`
+        },
+        body: authData.toString()
+      });
+      if (!response.ok) {
+        throw new Error(`Authentication failed: ${response.status}`);
+      }
+      const data = await response.json();
+      this.accessToken = data.access_token;
+      this.tokenExpiry = now + data.expires_in * 1e3;
+      this.authenticated = true;
+    } 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.makeRequest(`/user/${username}/about.json`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      const data = json.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.makeRequest(`/r/${subredditName}/about.json`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      const data = json.data;
+      return {
+        displayName: data.display_name,
+        title: data.title,
+        description: data.description || "",
+        publicDescription: data.public_description || "",
+        subscribers: data.subscribers,
+        activeUserCount: data.active_user_count ?? void 0,
+        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 params = new URLSearchParams({
+        t: timeFilter,
+        limit: limit.toString()
+      });
+      const response = await this.makeRequest(`${endpoint}?${params}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      return json.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 ?? void 0,
+          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.makeRequest(endpoint);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      let post;
+      if (subreddit) {
+        post = json[0].data.children[0].data;
+      } else {
+        if (!json.data.children.length) {
+          throw new Error(`Post with ID ${postId} not found`);
+        }
+        post = json.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 params = new URLSearchParams({ limit: limit.toString() });
+      const response = await this.makeRequest(`/subreddits/popular.json?${params}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      return json.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.makeRequest("/api/submit", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params.toString()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      if (json.success) {
+        const postId = json.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.makeRequest(`/api/info.json?id=t3_${postId}`);
+      if (!response.ok) {
+        return false;
+      }
+      const json = await response.json();
+      return json.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.makeRequest("/api/comment", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params.toString()
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const commentData = await response.json();
+      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}`);
+    }
+  }
+  async searchReddit(query, options = {}) {
+    await this.authenticate();
+    try {
+      const { subreddit, sort = "relevance", timeFilter = "all", limit = 25, type = "link" } = options;
+      const endpoint = subreddit ? `/r/${subreddit}/search.json` : "/search.json";
+      const params = new URLSearchParams({
+        q: query,
+        sort,
+        t: timeFilter,
+        limit: limit.toString(),
+        type,
+        ...subreddit && { restrict_sr: "true" }
+      });
+      const response = await this.makeRequest(`${endpoint}?${params}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      return json.data.children.filter((child) => child.kind === "t3").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 ?? void 0,
+          permalink: post.permalink
+        };
+      });
+    } catch {
+      throw new Error(`Failed to search Reddit for: ${query}`);
+    }
+  }
+  async getPostComments(postId, subreddit, options = {}) {
+    await this.authenticate();
+    try {
+      const { sort = "best", limit = 100 } = options;
+      const params = new URLSearchParams({
+        sort,
+        limit: limit.toString()
+      });
+      const response = await this.makeRequest(`/r/${subreddit}/comments/${postId}.json?${params}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      const postData = json[0].data.children[0].data;
+      const post = {
+        id: postData.id,
+        title: postData.title,
+        author: postData.author,
+        subreddit: postData.subreddit,
+        selftext: postData.selftext || "",
+        url: postData.url,
+        score: postData.score,
+        upvoteRatio: postData.upvote_ratio,
+        numComments: postData.num_comments,
+        createdUtc: postData.created_utc,
+        over18: postData.over_18,
+        spoiler: postData.spoiler,
+        edited: !!postData.edited,
+        isSelf: postData.is_self,
+        linkFlairText: postData.link_flair_text,
+        permalink: postData.permalink
+      };
+      const comments = [];
+      const parseComments = (commentData, depth = 0) => {
+        for (const item of commentData) {
+          if (item.kind === "t1" && item.data.body) {
+            comments.push({
+              id: item.data.id,
+              author: item.data.author,
+              body: item.data.body,
+              score: item.data.score,
+              controversiality: item.data.controversiality,
+              subreddit: item.data.subreddit,
+              submissionTitle: post.title,
+              createdUtc: item.data.created_utc,
+              edited: !!item.data.edited,
+              isSubmitter: item.data.is_submitter,
+              permalink: item.data.permalink,
+              depth,
+              parentId: item.data.parent_id
+            });
+            if (item.data.replies && item.data.replies.data && item.data.replies.data.children) {
+              parseComments(item.data.replies.data.children, depth + 1);
+            }
+          }
+        }
+      };
+      if (json[1] && json[1].data && json[1].data.children) {
+        parseComments(json[1].data.children);
+      }
+      return { post, comments };
+    } catch {
+      throw new Error(`Failed to get comments for post ${postId}`);
+    }
+  }
+  async getUserPosts(username, options = {}) {
+    await this.authenticate();
+    try {
+      const { sort = "new", timeFilter = "all", limit = 25 } = options;
+      const params = new URLSearchParams({
+        sort,
+        t: timeFilter,
+        limit: limit.toString()
+      });
+      const response = await this.makeRequest(`/user/${username}/submitted.json?${params}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      return json.data.children.filter((child) => child.kind === "t3").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 ?? void 0,
+          permalink: post.permalink
+        };
+      });
+    } catch {
+      throw new Error(`Failed to get posts for user ${username}`);
+    }
+  }
+  async getUserComments(username, options = {}) {
+    await this.authenticate();
+    try {
+      const { sort = "new", timeFilter = "all", limit = 25 } = options;
+      const params = new URLSearchParams({
+        sort,
+        t: timeFilter,
+        limit: limit.toString()
+      });
+      const response = await this.makeRequest(`/user/${username}/comments.json?${params}`);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const json = await response.json();
+      return json.data.children.filter((child) => child.kind === "t1").map((child) => {
+        const comment = child.data;
+        return {
+          id: comment.id,
+          author: comment.author,
+          body: comment.body,
+          score: comment.score,
+          controversiality: comment.controversiality,
+          subreddit: comment.subreddit,
+          submissionTitle: comment.link_title || "",
+          createdUtc: comment.created_utc,
+          edited: !!comment.edited,
+          isSubmitter: comment.is_submitter,
+          permalink: comment.permalink
+        };
+      });
+    } catch {
+      throw new Error(`Failed to get comments for user ${username}`);
+    }
+  }
+};
+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)
+  };
+}
+function formatPost(post) {
+  return {
+    title: post.title,
+    author: post.author,
+    subreddit: post.subreddit,
+    score: post.score,
+    upvoteRatio: Math.round(post.upvoteRatio * 100),
+    numComments: post.numComments,
+    createdAt: formatTimestamp(post.createdUtc),
+    selftext: post.selftext,
+    permalink: post.permalink,
+    nsfw: post.over18,
+    spoiler: post.spoiler
+  };
+}
+
+// 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)}`);
+  }
+}
+async function getUserPosts(params) {
+  const { username, sort = "new", time_filter = "all", limit = 10 } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    const posts = await client.getUserPosts(username, {
+      sort,
+      timeFilter: time_filter,
+      limit
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Posts by u/${username}
+
+## Sort: ${sort} | Time: ${time_filter} | Count: ${posts.length}
+
+${posts.map((post, index) => {
+            const date = new Date(post.createdUtc * 1e3).toLocaleString();
+            const selftext = post.selftext ? `
+${post.selftext.substring(0, 200)}${post.selftext.length > 200 ? "..." : ""}
+` : "";
+            return `### ${index + 1}. ${post.title}
+- Subreddit: r/${post.subreddit}
+- Score: ${post.score} (${Math.round(post.upvoteRatio * 100)}% upvoted)
+- Comments: ${post.numComments}
+- Posted: ${date}
+${selftext}
+- Link: https://reddit.com${post.permalink}
+${post.over18 ? "- **NSFW**" : ""}
+${post.spoiler ? "- **Spoiler**" : ""}`;
+          }).join("\n\n---\n\n")}`
+        }
+      ]
+    };
+  } catch (error) {
+    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user posts: ${String(error)}`);
+  }
+}
+async function getUserComments(params) {
+  const { username, sort = "new", time_filter = "all", limit = 10 } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  try {
+    const comments = await client.getUserComments(username, {
+      sort,
+      timeFilter: time_filter,
+      limit
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Comments by u/${username}
+
+## Sort: ${sort} | Time: ${time_filter} | Count: ${comments.length}
+
+${comments.map((comment, index) => {
+            const date = new Date(comment.createdUtc * 1e3).toLocaleString();
+            const edited = comment.edited ? " *(edited)*" : "";
+            const body = comment.body.length > 300 ? comment.body.substring(0, 300) + "..." : comment.body;
+            return `### ${index + 1}. In r/${comment.subreddit} on "${comment.submissionTitle}"
+- Score: ${comment.score} points
+- Posted: ${date}${edited}
+- Link: https://reddit.com${comment.permalink}
+
+${body}`;
+          }).join("\n\n---\n\n")}`
+        }
+      ]
+    };
+  } catch (error) {
+    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user comments: ${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/tools/search-tools.ts
+var import_types4 = require("@modelcontextprotocol/sdk/types.js");
+async function searchReddit(params) {
+  const { query, subreddit, sort = "relevance", time_filter = "all", limit = 10, type = "link" } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types4.McpError(import_types4.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  if (!query || query.trim().length === 0) {
+    throw new import_types4.McpError(import_types4.ErrorCode.InvalidParams, "Search query cannot be empty");
+  }
+  try {
+    const posts = await client.searchReddit(query, {
+      subreddit,
+      sort,
+      timeFilter: time_filter,
+      limit,
+      type
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Reddit Search Results for: "${query}"${subreddit ? ` in r/${subreddit}` : ""}
+
+## Search Parameters
+- Sort: ${sort}
+- Time Filter: ${time_filter}
+- Type: ${type}
+- Results: ${posts.length}
+
+${posts.map((post, index) => {
+            const formatted = formatPost(post);
+            return `### ${index + 1}. ${formatted.title}
+- Author: u/${formatted.author}
+- Subreddit: r/${formatted.subreddit}
+- Score: ${formatted.score} (${formatted.upvoteRatio}% upvoted)
+- Comments: ${formatted.numComments}
+- Posted: ${formatted.createdAt}
+${formatted.selftext ? `
+${formatted.selftext.substring(0, 200)}${formatted.selftext.length > 200 ? "..." : ""}
+` : ""}
+- Link: https://reddit.com${formatted.permalink}
+${formatted.nsfw ? "- **NSFW**" : ""}
+${formatted.spoiler ? "- **Spoiler**" : ""}
+`;
+          }).join("\n")}`
+        }
+      ]
+    };
+  } catch (error) {
+    throw new import_types4.McpError(import_types4.ErrorCode.InternalError, `Failed to search Reddit: ${String(error)}`);
+  }
+}
+
+// src/tools/comment-tools.ts
+var import_types5 = require("@modelcontextprotocol/sdk/types.js");
+async function getPostComments(params) {
+  const { post_id, subreddit, sort = "best", limit = 100 } = params;
+  const client = getRedditClient();
+  if (!client) {
+    throw new import_types5.McpError(import_types5.ErrorCode.InternalError, "Reddit client not initialized");
+  }
+  if (!post_id || !subreddit) {
+    throw new import_types5.McpError(import_types5.ErrorCode.InvalidParams, "post_id and subreddit are required");
+  }
+  try {
+    const { post, comments } = await client.getPostComments(post_id, subreddit, {
+      sort,
+      limit
+    });
+    const formattedPost = formatPost(post);
+    const formatComment = (comment) => {
+      const edited = comment.edited ? " *(edited)*" : "";
+      const submitter = comment.isSubmitter ? " **[OP]**" : "";
+      const depth = comment.depth || 0;
+      const prefix = "  ".repeat(depth) + (depth > 0 ? "\u2514\u2500 " : "");
+      return `${prefix}**u/${comment.author}**${submitter} \u2022 ${comment.score} points \u2022 ${new Date(comment.createdUtc * 1e3).toLocaleString()}${edited}
+${prefix}${comment.body.split("\n").join(`
+${prefix}`)}`;
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# Comments for: ${formattedPost.title}
+
+## Post Details
+- Author: u/${formattedPost.author}
+- Subreddit: r/${formattedPost.subreddit}
+- Score: ${formattedPost.score} (${formattedPost.upvoteRatio}% upvoted)
+- Posted: ${formattedPost.createdAt}
+- Link: https://reddit.com${formattedPost.permalink}
+
+## Post Content
+${formattedPost.selftext || "[Link post - no text content]"}
+
+## Comments (${comments.length} loaded, sorted by ${sort})
+
+${comments.map((comment) => formatComment(comment)).join("\n\n---\n\n")}`
+        }
+      ]
+    };
+  } catch (error) {
+    throw new import_types5.McpError(import_types5.ErrorCode.InternalError, `Failed to fetch comments: ${String(error)}`);
+  }
+}
+
+// src/middleware/auth.ts
+var import_http_exception = require("hono/http-exception");
+function createAuthMiddleware(config = {}) {
+  return async (c, next) => {
+    if (!config.enabled || !config.token) {
+      return next();
+    }
+    const authHeader = c.req.header("Authorization");
+    if (!authHeader) {
+      throw new import_http_exception.HTTPException(401, {
+        message: "Authorization header required"
+      });
+    }
+    const [scheme, token] = authHeader.split(" ");
+    if (scheme !== "Bearer") {
+      throw new import_http_exception.HTTPException(401, {
+        message: "Invalid authorization scheme. Use 'Bearer <token>'"
+      });
+    }
+    if (!token) {
+      throw new import_http_exception.HTTPException(401, {
+        message: "Bearer token required"
+      });
+    }
+    if (token !== config.token) {
+      throw new import_http_exception.HTTPException(403, {
+        message: "Invalid token"
+      });
+    }
+    return next();
+  };
+}
+function generateRandomToken(length = 32) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+// src/server.ts
+var import_dotenv = __toESM(require("dotenv"));
+import_dotenv.default.config();
+var app = new import_hono.Hono();
+var authToken = process.env.OAUTH_TOKEN || (process.env.OAUTH_ENABLED === "true" ? generateRandomToken() : void 0);
+var authConfig = {
+  enabled: process.env.OAUTH_ENABLED === "true",
+  token: authToken
+};
+if (authConfig.enabled) {
+  if (process.env.OAUTH_TOKEN) {
+    console.log("[Auth] OAuth enabled with provided token");
+  } else {
+    console.log(`[Auth] OAuth enabled with generated token: ${authToken}`);
+  }
+} else {
+  console.log("[Auth] OAuth disabled - server accessible without authentication");
+}
+app.use(
+  "*",
+  (0, import_cors.cors)({
+    origin: "*",
+    allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
+    allowHeaders: ["*"]
+  })
+);
+app.use("/mcp", createAuthMiddleware(authConfig));
+app.get("/", (c) => {
+  return c.json({
+    status: "ok",
+    service: "Reddit MCP Server",
+    endpoint: "/mcp",
+    version: "1.0.10",
+    auth: {
+      enabled: authConfig.enabled,
+      ...authConfig.enabled && { token_provided: !!process.env.OAUTH_TOKEN }
+    }
+  });
+});
+function createMCPServer() {
+  const server = new import_server.Server(
+    {
+      name: "reddit-mcp-server",
+      version: "1.0.10"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(import_types6.ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "test_reddit_mcp_server",
+        description: "Test the Reddit MCP Server",
+        inputSchema: {
+          type: "object",
+          properties: {}
+        }
+      },
+      {
+        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"]
+        }
+      },
+      {
+        name: "search_reddit",
+        description: "Search for posts on Reddit",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The search query"
+            },
+            subreddit: {
+              type: "string",
+              description: "Search within a specific subreddit (optional)"
+            },
+            sort: {
+              type: "string",
+              description: "Sort order: relevance, hot, top, new, comments",
+              enum: ["relevance", "hot", "top", "new", "comments"],
+              default: "relevance"
+            },
+            time_filter: {
+              type: "string",
+              description: "Time filter: hour, day, week, month, year, all",
+              enum: ["hour", "day", "week", "month", "year", "all"],
+              default: "all"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results to return",
+              minimum: 1,
+              maximum: 100,
+              default: 10
+            },
+            type: {
+              type: "string",
+              description: "Type of content: link (posts), sr (subreddits), user (users)",
+              enum: ["link", "sr", "user"],
+              default: "link"
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "get_post_comments",
+        description: "Get comments for a specific Reddit post",
+        inputSchema: {
+          type: "object",
+          properties: {
+            post_id: {
+              type: "string",
+              description: "The ID of the post"
+            },
+            subreddit: {
+              type: "string",
+              description: "The subreddit where the post is located"
+            },
+            sort: {
+              type: "string",
+              description: "Comment sort order: best, top, new, controversial, old, qa",
+              enum: ["best", "top", "new", "controversial", "old", "qa"],
+              default: "best"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of comments to load",
+              minimum: 1,
+              maximum: 500,
+              default: 100
+            }
+          },
+          required: ["post_id", "subreddit"]
+        }
+      },
+      {
+        name: "get_user_posts",
+        description: "Get posts submitted by a specific user",
+        inputSchema: {
+          type: "object",
+          properties: {
+            username: {
+              type: "string",
+              description: "The username to get posts for"
+            },
+            sort: {
+              type: "string",
+              description: "Sort order: new, hot, top, controversial",
+              enum: ["new", "hot", "top", "controversial"],
+              default: "new"
+            },
+            time_filter: {
+              type: "string",
+              description: "Time filter for top/controversial: hour, day, week, month, year, all",
+              enum: ["hour", "day", "week", "month", "year", "all"],
+              default: "all"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of posts to return",
+              minimum: 1,
+              maximum: 100,
+              default: 10
+            }
+          },
+          required: ["username"]
+        }
+      },
+      {
+        name: "get_user_comments",
+        description: "Get comments made by a specific user",
+        inputSchema: {
+          type: "object",
+          properties: {
+            username: {
+              type: "string",
+              description: "The username to get comments for"
+            },
+            sort: {
+              type: "string",
+              description: "Sort order: new, hot, top, controversial",
+              enum: ["new", "hot", "top", "controversial"],
+              default: "new"
+            },
+            time_filter: {
+              type: "string",
+              description: "Time filter for top/controversial: hour, day, week, month, year, all",
+              enum: ["hour", "day", "week", "month", "year", "all"],
+              default: "all"
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of comments to return",
+              minimum: 1,
+              maximum: 100,
+              default: 10
+            }
+          },
+          required: ["username"]
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(import_types6.CallToolRequestSchema, async (request) => {
+    try {
+      const toolName = request.params.name;
+      const toolParams = request.params.arguments || {};
+      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
+          );
+        case "search_reddit":
+          return await searchReddit(
+            toolParams
+          );
+        case "get_post_comments":
+          return await getPostComments(
+            toolParams
+          );
+        case "get_user_posts":
+          return await getUserPosts(
+            toolParams
+          );
+        case "get_user_comments":
+          return await getUserComments(
+            toolParams
+          );
+        default:
+          throw new import_types6.McpError(import_types6.ErrorCode.MethodNotFound, `Tool with name ${toolName} not found`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new import_types6.McpError(import_types6.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+      }
+      throw error;
+    }
+  });
+  return server;
+}
+function initializeReddit() {
+  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);
+  }
+}
+app.all("/mcp", async (c) => {
+  console.log(`[MCP] Request received: ${c.req.method} ${c.req.url}`);
+  try {
+    const mcpServer = createMCPServer();
+    const transport = new import_mcp.StreamableHTTPTransport();
+    await mcpServer.connect(transport);
+    return transport.handleRequest(c);
+  } catch (error) {
+    console.error("[MCP] Request handling failed:", error);
+    return c.json({ error: "Internal server error" }, 500);
+  }
+});
+initializeReddit();
+function startServer(port = 3e3) {
+  const server = (0, import_node_server.serve)({
+    fetch: app.fetch,
+    port
+  });
+  console.log(`[Server] Reddit MCP Server running at http://localhost:${port}`);
+  console.log(`[Server] MCP endpoint available at http://localhost:${port}/mcp`);
+  return server;
+}
+if (require.main === module) {
+  const port = parseInt(process.env.PORT || "3000", 10);
+  startServer(port);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startServer
+});