reddit-mcp-server 1.0.4 → 1.0.6

package/dist/index.js

@@ -35,10 +35,9 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 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");
+var import_types6 = require("@modelcontextprotocol/sdk/types.js");
 
 // src/client/reddit-client.ts
-var import_axios = __toESM(require("axios"));
 var RedditClient = class {
   clientId;
   clientSecret;
@@ -47,7 +46,7 @@ var RedditClient = class {
   password;
   accessToken;
   tokenExpiry = 0;
-  api;
+  baseUrl = "https://oauth.reddit.com";
   authenticated = false;
   constructor(config) {
     this.clientId = config.clientId;
@@ -55,24 +54,33 @@ var RedditClient = class {
     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
-      }
+  }
+  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
     });
-    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);
-      }
-    );
+    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 {
@@ -89,20 +97,23 @@ var RedditClient = class {
       } else {
         authData.append("grant_type", "client_credentials");
       }
-      const response = await import_axios.default.post(authUrl, authData, {
-        auth: {
-          username: this.clientId,
-          password: this.clientSecret
-        },
+      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"
-        }
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${credentials}`
+        },
+        body: authData.toString()
       });
-      this.accessToken = response.data.access_token;
-      this.tokenExpiry = now + response.data.expires_in * 1e3;
+      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;
-      this.api.defaults.headers.common["Authorization"] = `Bearer ${this.accessToken}`;
     } catch {
       throw new Error("Failed to authenticate with Reddit API");
     }
@@ -121,8 +132,12 @@ var RedditClient = class {
   async getUser(username) {
     await this.authenticate();
     try {
-      const response = await this.api.get(`/user/${username}/about.json`);
-      const data = response.data.data;
+      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,
@@ -142,8 +157,12 @@ var RedditClient = class {
   async getSubredditInfo(subredditName) {
     await this.authenticate();
     try {
-      const response = await this.api.get(`/r/${subredditName}/about.json`);
-      const data = response.data.data;
+      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,
@@ -164,13 +183,16 @@ var RedditClient = class {
     await this.authenticate();
     try {
       const endpoint = subreddit ? `/r/${subreddit}/top.json` : "/top.json";
-      const response = await this.api.get(endpoint, {
-        params: {
-          t: timeFilter,
-          limit
-        }
+      const params = new URLSearchParams({
+        t: timeFilter,
+        limit: limit.toString()
       });
-      return response.data.data.children.map((child) => {
+      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,
@@ -199,15 +221,19 @@ var RedditClient = class {
     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);
+      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 = response.data[0].data.children[0].data;
+        post = json[0].data.children[0].data;
       } else {
-        if (!response.data.data.children.length) {
+        if (!json.data.children.length) {
           throw new Error(`Post with ID ${postId} not found`);
         }
-        post = response.data.data.children[0].data;
+        post = json.data.children[0].data;
       }
       return {
         id: post.id,
@@ -234,10 +260,13 @@ var RedditClient = class {
   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);
+      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");
     }
@@ -254,13 +283,19 @@ var RedditClient = class {
       params.append("kind", kind);
       params.append("title", title);
       params.append(isSelf ? "text" : "url", content);
-      const response = await this.api.post("/api/submit", params, {
+      const response = await this.makeRequest("/api/submit", {
+        method: "POST",
         headers: {
           "Content-Type": "application/x-www-form-urlencoded"
-        }
+        },
+        body: params.toString()
       });
-      if (response.data.success) {
-        const postId = response.data.data.id;
+      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");
@@ -272,8 +307,12 @@ var RedditClient = class {
   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;
+      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;
     }
@@ -290,12 +329,17 @@ var RedditClient = class {
       const params = new URLSearchParams();
       params.append("thing_id", `t3_${postId}`);
       params.append("text", content);
-      const response = await this.api.post("/api/comment", params, {
+      const response = await this.makeRequest("/api/comment", {
+        method: "POST",
         headers: {
           "Content-Type": "application/x-www-form-urlencoded"
-        }
+        },
+        body: params.toString()
       });
-      const commentData = response.data;
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const commentData = await response.json();
       return {
         id: commentData.id,
         author: this.username,
@@ -313,6 +357,187 @@ var RedditClient = class {
       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,
+          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,
+          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) {
@@ -557,6 +782,21 @@ function formatCommentInfo(comment) {
     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");
@@ -599,6 +839,86 @@ async function getUserInfo(params) {
     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");
@@ -826,6 +1146,114 @@ ${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).j
   }
 }
 
+// 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/index.ts
 var import_dotenv = __toESM(require("dotenv"));
 import_dotenv.default.config();
@@ -864,9 +1292,6 @@ var RedditServer = class {
     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 {
@@ -877,13 +1302,12 @@ var RedditServer = class {
         username,
         password
       });
-    } catch (error) {
-      console.error("[Error] Failed to initialize Reddit client:", error);
+    } catch {
       process.exit(1);
     }
   }
   setupToolHandlers() {
-    this.server.setRequestHandler(import_types4.ListToolsRequestSchema, async () => ({
+    this.server.setRequestHandler(import_types6.ListToolsRequestSchema, async () => ({
       tools: [
         {
           name: "test_reddit_mcp_server",
@@ -1022,10 +1446,150 @@ var RedditServer = class {
             },
             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"]
+          }
         }
       ]
     }));
-    this.server.setRequestHandler(import_types4.CallToolRequestSchema, async (request) => {
+    this.server.setRequestHandler(import_types6.CallToolRequestSchema, async (request) => {
       try {
         const toolName = request.params.name;
         const toolParams = request.params.arguments || {};
@@ -1064,8 +1628,24 @@ var RedditServer = class {
             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_types4.McpError(import_types4.ErrorCode.MethodNotFound, `Tool with name ${toolName} not found`);
+            throw new import_types6.McpError(import_types6.ErrorCode.MethodNotFound, `Tool with name ${toolName} not found`);
         }
       } catch (error) {
         if (error instanceof Error) {
@@ -1074,7 +1654,7 @@ var RedditServer = class {
             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 new import_types6.McpError(import_types6.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
         }
         throw error;
       }
@@ -1099,7 +1679,9 @@ var RedditServer = class {
 };
 if (require.main === module) {
   const server = new RedditServer();
-  server.run().catch(console.error);
+  server.run().catch(() => {
+    process.exit(1);
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {