reddit-mcp-server 1.0.7 → 1.0.9

package/dist/bin.js

@@ -6,6 +6,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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))
@@ -23,521 +30,530 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/index.ts
-var import_server = require("@modelcontextprotocol/sdk/server/index.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_types6 = require("@modelcontextprotocol/sdk/types.js");
+// node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_typescript@5.8.3/node_modules/tsup/assets/cjs_shims.js
+var init_cjs_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_typescript@5.8.3/node_modules/tsup/assets/cjs_shims.js"() {
+    "use strict";
+  }
+});
 
 // 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");
+function initializeRedditClient(config) {
+  redditClient = new RedditClient(config);
+  return redditClient;
+}
+function getRedditClient() {
+  return redditClient;
+}
+var RedditClient, redditClient;
+var init_reddit_client = __esm({
+  "src/client/reddit-client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    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;
       }
-      const credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
-      const response = await fetch(authUrl, {
-        method: "POST",
-        headers: {
+      async makeRequest(path2, options = {}) {
+        if (Date.now() >= this.tokenExpiry || !this.authenticated) {
+          await this.authenticate();
+        }
+        const url = `${this.baseUrl}${path2}`;
+        const 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}`);
+          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;
       }
-      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,
-        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}`);
+      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");
+        }
       }
-      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,
-          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}`);
+      async checkAuthentication() {
+        if (!this.authenticated) {
+          try {
+            await this.authenticate();
+            return true;
+          } catch {
+            return false;
+          }
+        }
+        return true;
       }
-      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`);
+      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}`);
         }
-        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}`);
+      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,
+            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}`);
+        }
       }
-      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}`);
+      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,
+              permalink: post.permalink
+            };
+          });
+        } catch {
+          throw new Error(`Failed to get top posts for ${subreddit || "home"}`);
+        }
       }
-      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");
+      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}`);
+        }
       }
-    } 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;
+      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");
+        }
       }
-      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`);
+      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}`);
+        }
       }
-      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}`);
+      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;
+        }
       }
-      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}`);
+      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}`);
+        }
       }
-      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}`);
+      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}`);
+        }
       }
-      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);
+      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}`);
         }
-      };
-      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}`);
+      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}`);
+        }
       }
-      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}`);
+      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}`);
+        }
       }
-      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}`);
-    }
+    };
+    redditClient = null;
   }
-};
-var redditClient = null;
-function initializeRedditClient(config) {
-  redditClient = new RedditClient(config);
-  return redditClient;
-}
-function getRedditClient() {
-  return redditClient;
-}
+});
 
 // src/utils/formatters.ts
 function formatTimestamp(timestamp) {
@@ -788,9 +804,14 @@ function formatPost(post) {
     spoiler: post.spoiler
   };
 }
+var init_formatters = __esm({
+  "src/utils/formatters.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
 
 // src/tools/user-tools.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
 async function getUserInfo(params) {
   const { username } = params;
   const client = getRedditClient();
@@ -910,9 +931,18 @@ ${body}`;
     throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user comments: ${String(error)}`);
   }
 }
+var import_types;
+var init_user_tools = __esm({
+  "src/tools/user-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_reddit_client();
+    init_formatters();
+    import_types = require("@modelcontextprotocol/sdk/types.js");
+  }
+});
 
 // 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();
@@ -1061,9 +1091,18 @@ Your reply has been successfully posted.
     throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to reply to post: ${String(error)}`);
   }
 }
+var import_types2;
+var init_post_tools = __esm({
+  "src/tools/post-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_reddit_client();
+    init_formatters();
+    import_types2 = require("@modelcontextprotocol/sdk/types.js");
+  }
+});
 
 // src/tools/subreddit-tools.ts
-var import_types3 = require("@modelcontextprotocol/sdk/types.js");
 async function getSubredditInfo(params) {
   const { subreddit_name } = params;
   const client = getRedditClient();
@@ -1136,9 +1175,18 @@ ${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).j
     throw new import_types3.McpError(import_types3.ErrorCode.InternalError, `Failed to fetch trending subreddits: ${String(error)}`);
   }
 }
+var import_types3;
+var init_subreddit_tools = __esm({
+  "src/tools/subreddit-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_reddit_client();
+    init_formatters();
+    import_types3 = require("@modelcontextprotocol/sdk/types.js");
+  }
+});
 
 // 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();
@@ -1191,9 +1239,18 @@ ${formatted.spoiler ? "- **Spoiler**" : ""}
     throw new import_types4.McpError(import_types4.ErrorCode.InternalError, `Failed to search Reddit: ${String(error)}`);
   }
 }
+var import_types4;
+var init_search_tools = __esm({
+  "src/tools/search-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_reddit_client();
+    init_formatters();
+    import_types4 = require("@modelcontextprotocol/sdk/types.js");
+  }
+});
 
 // 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();
@@ -1244,439 +1301,519 @@ ${comments.map((comment) => formatComment(comment)).join("\n\n---\n\n")}`
     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();
-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);
-    });
+var import_types5;
+var init_comment_tools = __esm({
+  "src/tools/comment-tools.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_reddit_client();
+    init_formatters();
+    import_types5 = require("@modelcontextprotocol/sdk/types.js");
   }
-  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) {
-      process.exit(1);
-    }
-    try {
-      initializeRedditClient({
-        clientId,
-        clientSecret,
-        userAgent,
-        username,
-        password
-      });
-    } catch {
-      process.exit(1);
-    }
+});
+
+// src/tools/index.ts
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_user_tools();
+    init_post_tools();
+    init_subreddit_tools();
+    init_search_tools();
+    init_comment_tools();
   }
-  setupToolHandlers() {
-    this.server.setRequestHandler(import_types6.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
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  RedditServer: () => RedditServer
+});
+var import_server, import_stdio, import_types6, import_dotenv, RedditServer;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_server = require("@modelcontextprotocol/sdk/server/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    import_types6 = require("@modelcontextprotocol/sdk/types.js");
+    init_reddit_client();
+    init_tools();
+    import_dotenv = __toESM(require("dotenv"));
+    import_dotenv.default.config();
+    RedditServer = class {
+      server;
+      constructor() {
+        this.server = new import_server.Server(
+          {
+            name: "reddit-mcp-server",
+            version: "0.1.0"
+          },
+          {
+            capabilities: {
+              tools: {},
+              logging: {}
             }
           }
-        },
-        {
-          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"
+        );
+        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
+          });
+          console.error("[Setup] Reddit client initialized");
+          if (username && password) {
+            console.error(`[Setup] Authenticated as user: ${username}`);
+          } else {
+            console.error("[Setup] Running in read-only mode (no user authentication)");
+          }
+        } catch (error) {
+          console.error("[Error] Failed to initialize Reddit client:", error);
+          process.exit(1);
+        }
+      }
+      setupToolHandlers() {
+        this.server.setRequestHandler(import_types6.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
+                }
               }
             },
-            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
+            {
+              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"]
               }
             },
-            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"
+            {
+              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"]
               }
             },
-            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"
+            {
+              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"]
               }
             },
-            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
+            {
+              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"]
               }
             },
-            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)"
+            {
+              name: "get_trending_subreddits",
+              description: "Get currently trending subreddits",
+              inputSchema: {
+                type: "object",
+                properties: {}
               }
             },
-            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"
+            {
+              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"]
               }
             },
-            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
+            {
+              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"]
               }
             },
-            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
+            {
+              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"]
               }
             },
-            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
+            {
+              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"]
               }
             },
-            required: ["username"]
+            {
+              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_types6.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
+                );
+              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) {
+              await this.server.sendLoggingMessage({
+                level: "error",
+                logger: "reddit-server",
+                data: `Error calling tool: ${error.message}`
+              });
+              throw new import_types6.McpError(import_types6.ErrorCode.InternalError, `Failed to fetch data: ${error.message}`);
+            }
+            throw error;
           }
-        }
-      ]
-    }));
-    this.server.setRequestHandler(import_types6.CallToolRequestSchema, async (request) => {
-      try {
-        const toolName = request.params.name;
-        const toolParams = request.params.arguments || {};
+        });
+      }
+      async run() {
+        const transport = new import_stdio.StdioServerTransport();
+        await this.server.connect(transport);
         await this.server.sendLoggingMessage({
-          level: "debug",
+          level: "info",
           logger: "reddit-server",
-          data: `Tool call: ${toolName}`
+          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)"
         });
-        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) {
-          await this.server.sendLoggingMessage({
-            level: "error",
-            logger: "reddit-server",
-            data: `Error calling tool: ${error.message}`
-          });
-          throw new import_types6.McpError(import_types6.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(() => {
+});
+
+// src/bin.ts
+init_cjs_shims();
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var packageJsonPath = import_path.default.join(__dirname, "..", "package.json");
+var packageJson = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+var args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+  console.log(packageJson.version);
+  process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h")) {
+  console.log(`
+Reddit MCP Server v${packageJson.version}
+
+Usage: reddit-mcp-server [options]
+
+Options:
+  -v, --version     Show version number
+  -h, --help        Show help
+
+Environment Variables:
+  REDDIT_CLIENT_ID      Reddit API client ID (required)
+  REDDIT_CLIENT_SECRET  Reddit API client secret (required)
+  REDDIT_USERNAME       Reddit username (optional, for write operations)
+  REDDIT_PASSWORD       Reddit password (optional, for write operations)
+  REDDIT_USER_AGENT     Custom user agent (optional)
+
+For more information, visit: https://github.com/jordanburke/reddit-mcp-server
+`);
+  process.exit(0);
+}
+async function main() {
+  const { RedditServer: RedditServer2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+  const server = new RedditServer2();
+  server.run().catch((error) => {
+    console.error(error);
     process.exit(1);
   });
 }
-
-// src/bin.ts
-var server = new RedditServer();
-server.run().catch(() => {
-  process.exit(1);
-});
+main().then();