reddit-mcp-server 1.1.1 → 1.2.0

package/dist/bin.js

@@ -1,1249 +1,22 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.5_typescript@5.9.2/node_modules/tsup/assets/cjs_shims.js
-var init_cjs_shims = __esm({
-  "node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.5_typescript@5.9.2/node_modules/tsup/assets/cjs_shims.js"() {
-    "use strict";
-  }
-});
-
-// src/client/reddit-client.ts
-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;
-      }
-      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,
-          Authorization: `Bearer ${this.accessToken}`,
-          ...options.headers
-        };
-        const response = await fetch(url, {
-          ...options,
-          headers
-        });
-        if (response.status === 401 && this.authenticated) {
-          await this.authenticate();
-          const retryHeaders = {
-            ...headers,
-            Authorization: `Bearer ${this.accessToken}`
-          };
-          return fetch(url, {
-            ...options,
-            headers: retryHeaders
-          });
-        }
-        return response;
-      }
-      async authenticate() {
-        try {
-          const now = Date.now();
-          if (this.accessToken && now < this.tokenExpiry) {
-            return;
-          }
-          const authUrl = "https://www.reddit.com/api/v1/access_token";
-          const authData = new URLSearchParams();
-          if (this.username && this.password) {
-            authData.append("grant_type", "password");
-            authData.append("username", this.username);
-            authData.append("password", this.password);
-          } else {
-            authData.append("grant_type", "client_credentials");
-          }
-          const credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
-          const response = await fetch(authUrl, {
-            method: "POST",
-            headers: {
-              "User-Agent": this.userAgent,
-              "Content-Type": "application/x-www-form-urlencoded",
-              Authorization: `Basic ${credentials}`
-            },
-            body: authData.toString()
-          });
-          if (!response.ok) {
-            throw new Error(`Authentication failed: ${response.status}`);
-          }
-          const data = await response.json();
-          this.accessToken = data.access_token;
-          this.tokenExpiry = now + data.expires_in * 1e3;
-          this.authenticated = true;
-        } catch {
-          throw new Error("Failed to authenticate with Reddit API");
-        }
-      }
-      async checkAuthentication() {
-        if (!this.authenticated) {
-          try {
-            await this.authenticate();
-            return true;
-          } catch {
-            return false;
-          }
-        }
-        return true;
-      }
-      async getUser(username) {
-        await this.authenticate();
-        try {
-          const response = await this.makeRequest(`/user/${username}/about.json`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          const data = json.data;
-          return {
-            name: data.name,
-            id: data.id,
-            commentKarma: data.comment_karma,
-            linkKarma: data.link_karma,
-            totalKarma: data.total_karma || data.comment_karma + data.link_karma,
-            isMod: data.is_mod,
-            isGold: data.is_gold,
-            isEmployee: data.is_employee,
-            createdUtc: data.created_utc,
-            profileUrl: `https://reddit.com/user/${data.name}`
-          };
-        } catch {
-          throw new Error(`Failed to get user info for ${username}`);
-        }
-      }
-      async getSubredditInfo(subredditName) {
-        await this.authenticate();
-        try {
-          const response = await this.makeRequest(`/r/${subredditName}/about.json`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          const data = json.data;
-          return {
-            displayName: data.display_name,
-            title: data.title,
-            description: data.description || "",
-            publicDescription: data.public_description || "",
-            subscribers: data.subscribers,
-            activeUserCount: data.active_user_count ?? void 0,
-            createdUtc: data.created_utc,
-            over18: data.over18,
-            subredditType: data.subreddit_type,
-            url: data.url
-          };
-        } catch {
-          throw new Error(`Failed to get subreddit info for ${subredditName}`);
-        }
-      }
-      async getTopPosts(subreddit, timeFilter = "week", limit = 10) {
-        await this.authenticate();
-        try {
-          const endpoint = subreddit ? `/r/${subreddit}/top.json` : "/top.json";
-          const params = new URLSearchParams({
-            t: timeFilter,
-            limit: limit.toString()
-          });
-          const response = await this.makeRequest(`${endpoint}?${params}`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          return json.data.children.map((child) => {
-            const post = child.data;
-            return {
-              id: post.id,
-              title: post.title,
-              author: post.author,
-              subreddit: post.subreddit,
-              selftext: post.selftext,
-              url: post.url,
-              score: post.score,
-              upvoteRatio: post.upvote_ratio,
-              numComments: post.num_comments,
-              createdUtc: post.created_utc,
-              over18: post.over_18,
-              spoiler: post.spoiler,
-              edited: !!post.edited,
-              isSelf: post.is_self,
-              linkFlairText: post.link_flair_text ?? void 0,
-              permalink: post.permalink
-            };
-          });
-        } catch {
-          throw new Error(`Failed to get top posts for ${subreddit || "home"}`);
-        }
-      }
-      async getPost(postId, subreddit) {
-        await this.authenticate();
-        try {
-          const endpoint = subreddit ? `/r/${subreddit}/comments/${postId}.json` : `/api/info.json?id=t3_${postId}`;
-          const response = await this.makeRequest(endpoint);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          let post;
-          if (subreddit) {
-            post = json[0].data.children[0].data;
-          } else {
-            if (!json.data.children.length) {
-              throw new Error(`Post with ID ${postId} not found`);
-            }
-            post = json.data.children[0].data;
-          }
-          return {
-            id: post.id,
-            title: post.title,
-            author: post.author,
-            subreddit: post.subreddit,
-            selftext: post.selftext,
-            url: post.url,
-            score: post.score,
-            upvoteRatio: post.upvote_ratio,
-            numComments: post.num_comments,
-            createdUtc: post.created_utc,
-            over18: post.over_18,
-            spoiler: post.spoiler,
-            edited: !!post.edited,
-            isSelf: post.is_self,
-            linkFlairText: post.link_flair_text,
-            permalink: post.permalink
-          };
-        } catch {
-          throw new Error(`Failed to get post with ID ${postId}`);
-        }
-      }
-      async getTrendingSubreddits(limit = 5) {
-        await this.authenticate();
-        try {
-          const params = new URLSearchParams({ limit: limit.toString() });
-          const response = await this.makeRequest(`/subreddits/popular.json?${params}`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          return json.data.children.map((child) => child.data.display_name);
-        } catch {
-          throw new Error("Failed to get trending subreddits");
-        }
-      }
-      async createPost(subreddit, title, content, isSelf = true) {
-        await this.authenticate();
-        if (!this.username || !this.password) {
-          throw new Error("User authentication required for posting");
-        }
-        try {
-          const kind = isSelf ? "self" : "link";
-          const params = new URLSearchParams();
-          params.append("sr", subreddit);
-          params.append("kind", kind);
-          params.append("title", title);
-          params.append(isSelf ? "text" : "url", content);
-          const response = await this.makeRequest("/api/submit", {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/x-www-form-urlencoded"
-            },
-            body: params.toString()
-          });
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          if (json.success) {
-            const postId = json.data.id;
-            return await this.getPost(postId);
-          } else {
-            throw new Error("Failed to create post");
-          }
-        } catch {
-          throw new Error(`Failed to create post in ${subreddit}`);
-        }
-      }
-      async checkPostExists(postId) {
-        await this.authenticate();
-        try {
-          const response = await this.makeRequest(`/api/info.json?id=t3_${postId}`);
-          if (!response.ok) {
-            return false;
-          }
-          const json = await response.json();
-          return json.data.children.length > 0;
-        } catch {
-          return false;
-        }
-      }
-      async replyToPost(postId, content) {
-        await this.authenticate();
-        if (!this.username || !this.password) {
-          throw new Error("User authentication required for posting replies");
-        }
-        try {
-          if (!await this.checkPostExists(postId)) {
-            throw new Error(`Post with ID ${postId} does not exist or is not accessible`);
-          }
-          const params = new URLSearchParams();
-          params.append("thing_id", `t3_${postId}`);
-          params.append("text", content);
-          const response = await this.makeRequest("/api/comment", {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/x-www-form-urlencoded"
-            },
-            body: params.toString()
-          });
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const commentData = await response.json();
-          return {
-            id: commentData.id,
-            author: this.username,
-            body: content,
-            score: 1,
-            controversiality: 0,
-            subreddit: commentData.subreddit,
-            submissionTitle: commentData.link_title,
-            createdUtc: Date.now() / 1e3,
-            edited: false,
-            isSubmitter: false,
-            permalink: commentData.permalink
-          };
-        } catch {
-          throw new Error(`Failed to reply to post ${postId}`);
-        }
-      }
-      async searchReddit(query, options = {}) {
-        await this.authenticate();
-        try {
-          const { subreddit, sort = "relevance", timeFilter = "all", limit = 25, type = "link" } = options;
-          const endpoint = subreddit ? `/r/${subreddit}/search.json` : "/search.json";
-          const params = new URLSearchParams({
-            q: query,
-            sort,
-            t: timeFilter,
-            limit: limit.toString(),
-            type,
-            ...subreddit && { restrict_sr: "true" }
-          });
-          const response = await this.makeRequest(`${endpoint}?${params}`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          return json.data.children.filter((child) => child.kind === "t3").map((child) => {
-            const post = child.data;
-            return {
-              id: post.id,
-              title: post.title,
-              author: post.author,
-              subreddit: post.subreddit,
-              selftext: post.selftext || "",
-              url: post.url,
-              score: post.score,
-              upvoteRatio: post.upvote_ratio,
-              numComments: post.num_comments,
-              createdUtc: post.created_utc,
-              over18: post.over_18,
-              spoiler: post.spoiler,
-              edited: !!post.edited,
-              isSelf: post.is_self,
-              linkFlairText: post.link_flair_text ?? void 0,
-              permalink: post.permalink
-            };
-          });
-        } catch {
-          throw new Error(`Failed to search Reddit for: ${query}`);
-        }
-      }
-      async getPostComments(postId, subreddit, options = {}) {
-        await this.authenticate();
-        try {
-          const { sort = "best", limit = 100 } = options;
-          const params = new URLSearchParams({
-            sort,
-            limit: limit.toString()
-          });
-          const response = await this.makeRequest(`/r/${subreddit}/comments/${postId}.json?${params}`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          const postData = json[0].data.children[0].data;
-          const post = {
-            id: postData.id,
-            title: postData.title,
-            author: postData.author,
-            subreddit: postData.subreddit,
-            selftext: postData.selftext || "",
-            url: postData.url,
-            score: postData.score,
-            upvoteRatio: postData.upvote_ratio,
-            numComments: postData.num_comments,
-            createdUtc: postData.created_utc,
-            over18: postData.over_18,
-            spoiler: postData.spoiler,
-            edited: !!postData.edited,
-            isSelf: postData.is_self,
-            linkFlairText: postData.link_flair_text,
-            permalink: postData.permalink
-          };
-          const comments = [];
-          const parseComments = (commentData, depth = 0) => {
-            for (const item of commentData) {
-              if (item.kind === "t1" && item.data.body) {
-                comments.push({
-                  id: item.data.id,
-                  author: item.data.author,
-                  body: item.data.body,
-                  score: item.data.score,
-                  controversiality: item.data.controversiality,
-                  subreddit: item.data.subreddit,
-                  submissionTitle: post.title,
-                  createdUtc: item.data.created_utc,
-                  edited: !!item.data.edited,
-                  isSubmitter: item.data.is_submitter,
-                  permalink: item.data.permalink,
-                  depth,
-                  parentId: item.data.parent_id
-                });
-                if (item.data.replies && item.data.replies.data && item.data.replies.data.children) {
-                  parseComments(item.data.replies.data.children, depth + 1);
-                }
-              }
-            }
-          };
-          if (json[1] && json[1].data && json[1].data.children) {
-            parseComments(json[1].data.children);
-          }
-          return { post, comments };
-        } catch {
-          throw new Error(`Failed to get comments for post ${postId}`);
-        }
-      }
-      async getUserPosts(username, options = {}) {
-        await this.authenticate();
-        try {
-          const { sort = "new", timeFilter = "all", limit = 25 } = options;
-          const params = new URLSearchParams({
-            sort,
-            t: timeFilter,
-            limit: limit.toString()
-          });
-          const response = await this.makeRequest(`/user/${username}/submitted.json?${params}`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          return json.data.children.filter((child) => child.kind === "t3").map((child) => {
-            const post = child.data;
-            return {
-              id: post.id,
-              title: post.title,
-              author: post.author,
-              subreddit: post.subreddit,
-              selftext: post.selftext || "",
-              url: post.url,
-              score: post.score,
-              upvoteRatio: post.upvote_ratio,
-              numComments: post.num_comments,
-              createdUtc: post.created_utc,
-              over18: post.over_18,
-              spoiler: post.spoiler,
-              edited: !!post.edited,
-              isSelf: post.is_self,
-              linkFlairText: post.link_flair_text ?? void 0,
-              permalink: post.permalink
-            };
-          });
-        } catch {
-          throw new Error(`Failed to get posts for user ${username}`);
-        }
-      }
-      async getUserComments(username, options = {}) {
-        await this.authenticate();
-        try {
-          const { sort = "new", timeFilter = "all", limit = 25 } = options;
-          const params = new URLSearchParams({
-            sort,
-            t: timeFilter,
-            limit: limit.toString()
-          });
-          const response = await this.makeRequest(`/user/${username}/comments.json?${params}`);
-          if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-          }
-          const json = await response.json();
-          return json.data.children.filter((child) => child.kind === "t1").map((child) => {
-            const comment = child.data;
-            return {
-              id: comment.id,
-              author: comment.author,
-              body: comment.body,
-              score: comment.score,
-              controversiality: comment.controversiality,
-              subreddit: comment.subreddit,
-              submissionTitle: comment.link_title || "",
-              createdUtc: comment.created_utc,
-              edited: !!comment.edited,
-              isSubmitter: comment.is_submitter,
-              permalink: comment.permalink
-            };
-          });
-        } catch {
-          throw new Error(`Failed to get comments for user ${username}`);
-        }
-      }
-    };
-    redditClient = null;
-  }
-});
-
-// src/utils/formatters.ts
-function formatTimestamp(timestamp) {
-  try {
-    const date = new Date(timestamp * 1e3);
-    return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
-  } catch {
-    return String(timestamp);
-  }
-}
-function analyzeUserActivity(karmaRatio, isMod, accountAgeDays) {
-  const insights = [];
-  if (karmaRatio > 5) {
-    insights.push("Primarily a commenter, highly engaged in discussions");
-  } else if (karmaRatio < 0.2) {
-    insights.push("Content creator, focuses on sharing posts");
-  } else {
-    insights.push("Balanced participation in both posting and commenting");
-  }
-  if (accountAgeDays < 30) {
-    insights.push("New user, still exploring Reddit");
-  } else if (accountAgeDays > 365 * 5) {
-    insights.push("Long-time Redditor with extensive platform experience");
-  }
-  if (isMod) {
-    insights.push("Community leader who helps maintain subreddit quality");
-  }
-  return insights.join("\n  - ");
-}
-function analyzePostEngagement(score, ratio, numComments) {
-  const insights = [];
-  if (score > 1e3 && ratio > 0.95) {
-    insights.push("Highly successful post with strong community approval");
-  } else if (score > 100 && ratio > 0.8) {
-    insights.push("Well-received post with good engagement");
-  } else if (ratio < 0.5) {
-    insights.push("Controversial post that sparked debate");
-  }
-  if (numComments > 100) {
-    insights.push("Generated significant discussion");
-  } else if (numComments > score * 0.5) {
-    insights.push("Highly discussable content with active comment section");
-  } else if (numComments === 0) {
-    insights.push("Yet to receive community interaction");
-  }
-  return insights.join("\n  - ");
-}
-function analyzeSubredditHealth(subscribers, activeUsers, ageDays) {
-  const insights = [];
-  if (subscribers > 1e6) {
-    insights.push("Major subreddit with massive following");
-  } else if (subscribers > 1e5) {
-    insights.push("Well-established community");
-  } else if (subscribers < 1e3) {
-    insights.push("Niche community, potential for growth");
-  }
-  if (activeUsers) {
-    const activityRatio = activeUsers / subscribers;
-    if (activityRatio > 0.1) {
-      insights.push("Highly active community with strong engagement");
-    } else if (activityRatio < 0.01) {
-      insights.push("Could benefit from more community engagement initiatives");
-    }
-  }
-  if (ageDays > 365 * 5) {
-    insights.push("Mature subreddit with established culture");
-  } else if (ageDays < 90) {
-    insights.push("New subreddit still forming its community");
-  }
-  return insights.join("\n  - ");
-}
-function getUserRecommendations(karmaRatio, isMod, accountAgeDays) {
-  const recommendations = [];
-  if (karmaRatio > 5) {
-    recommendations.push("Consider creating more posts to share your expertise");
-  } else if (karmaRatio < 0.2) {
-    recommendations.push("Engage more in discussions to build community connections");
-  }
-  if (accountAgeDays < 30) {
-    recommendations.push("Explore popular subreddits in your areas of interest");
-    recommendations.push("Read community guidelines before posting");
-  }
-  if (isMod) {
-    recommendations.push("Share moderation insights with other community leaders");
-  }
-  if (!recommendations.length) {
-    recommendations.push("Maintain your balanced engagement across Reddit");
-  }
-  return recommendations.join("\n  - ");
-}
-function getBestEngagementTime(createdUtc) {
-  const postHour = new Date(createdUtc * 1e3).getHours();
-  if (14 <= postHour && postHour <= 18) {
-    return "Posted during peak engagement hours (2 PM - 6 PM), good timing!";
-  } else if (23 <= postHour || postHour <= 5) {
-    return "Consider posting during more active hours (morning to evening)";
-  } else {
-    return "Posted during moderate activity hours, timing could be optimized";
-  }
-}
-function getSubredditEngagementTips(subreddit) {
-  const tips = [];
-  if (subreddit.subscribers > 1e6) {
-    tips.push("Post during peak hours for maximum visibility");
-    tips.push("Ensure content is highly polished due to high competition");
-  } else if (subreddit.subscribers < 1e3) {
-    tips.push("Engage actively to help grow the community");
-    tips.push("Consider cross-posting to related larger subreddits");
-  }
-  if (subreddit.activeUserCount) {
-    const activityRatio = subreddit.activeUserCount / subreddit.subscribers;
-    if (activityRatio > 0.1) {
-      tips.push("Quick responses recommended due to high activity");
-    }
-  }
-  return tips.length ? tips.join("\n  - ") : "Regular engagement recommended to maintain community presence";
-}
-function formatUserInfo(user) {
-  const status = [];
-  if (user.isMod) status.push("Moderator");
-  if (user.isGold) status.push("Reddit Gold Member");
-  if (user.isEmployee) status.push("Reddit Employee");
-  const accountAgeDays = (Date.now() / 1e3 - user.createdUtc) / (24 * 3600);
-  const karmaRatio = user.commentKarma / (user.linkKarma || 1);
-  return {
-    username: user.name,
-    karma: {
-      commentKarma: user.commentKarma,
-      postKarma: user.linkKarma,
-      totalKarma: user.totalKarma
-    },
-    accountStatus: status.length ? status : ["Regular User"],
-    accountCreated: formatTimestamp(user.createdUtc),
-    profileUrl: user.profileUrl,
-    activityAnalysis: analyzeUserActivity(karmaRatio, user.isMod, accountAgeDays),
-    recommendations: getUserRecommendations(karmaRatio, user.isMod, accountAgeDays)
-  };
-}
-function formatPostInfo(post) {
-  const contentType = post.isSelf ? "Text Post" : "Link Post";
-  const content = post.isSelf ? post.selftext || "" : post.url || "";
-  const flags = [];
-  if (post.over18) flags.push("NSFW");
-  if (post.spoiler) flags.push("Spoiler");
-  if (post.edited) flags.push("Edited");
-  return {
-    title: post.title,
-    type: contentType,
-    content: content.length > 300 ? content.substring(0, 297) + "..." : content,
-    author: post.author,
-    subreddit: post.subreddit,
-    stats: {
-      score: post.score,
-      upvoteRatio: post.upvoteRatio,
-      comments: post.numComments
-    },
-    metadata: {
-      posted: formatTimestamp(post.createdUtc),
-      flags,
-      flair: post.linkFlairText || "None"
-    },
-    links: {
-      fullPost: `https://reddit.com${post.permalink}`,
-      shortLink: `https://redd.it/${post.id}`
-    },
-    engagementAnalysis: analyzePostEngagement(post.score, post.upvoteRatio, post.numComments),
-    bestTimeToEngage: getBestEngagementTime(post.createdUtc)
-  };
-}
-function formatSubredditInfo(subreddit) {
-  const flags = [];
-  if (subreddit.over18) flags.push("NSFW");
-  if (subreddit.subredditType) flags.push(`Type: ${subreddit.subredditType}`);
-  const ageDays = (Date.now() / 1e3 - subreddit.createdUtc) / (24 * 3600);
-  return {
-    name: subreddit.displayName,
-    title: subreddit.title,
-    stats: {
-      subscribers: subreddit.subscribers,
-      activeUsers: subreddit.activeUserCount !== void 0 ? subreddit.activeUserCount : "Unknown"
-    },
-    description: {
-      short: subreddit.publicDescription,
-      full: subreddit.description.length > 300 ? subreddit.description.substring(0, 297) + "..." : subreddit.description
-    },
-    metadata: {
-      created: formatTimestamp(subreddit.createdUtc),
-      flags: flags.length ? flags : ["None"]
-    },
-    links: {
-      subreddit: `https://reddit.com${subreddit.url}`,
-      wiki: `https://reddit.com/r/${subreddit.displayName}/wiki`
-    },
-    communityAnalysis: analyzeSubredditHealth(subreddit.subscribers, subreddit.activeUserCount, ageDays),
-    engagementTips: getSubredditEngagementTips(subreddit)
-  };
-}
-var init_formatters = __esm({
-  "src/utils/formatters.ts"() {
-    "use strict";
-    init_cjs_shims();
-  }
-});
-
-// src/index.ts
-var src_exports = {};
-async function setupRedditClient() {
-  const clientId = process.env.REDDIT_CLIENT_ID;
-  const clientSecret = process.env.REDDIT_CLIENT_SECRET;
-  const userAgent = process.env.REDDIT_USER_AGENT || "RedditMCPServer/1.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);
-  }
-}
-async function main() {
-  try {
-    await setupRedditClient();
-    await server.start({
-      transportType: "stdio"
-    });
-  } catch (error) {
-    console.error("[Error] Failed to start server:", error);
-    process.exit(1);
-  }
-}
-var import_fastmcp, import_zod, import_dotenv, server;
-var init_src = __esm({
-  "src/index.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_fastmcp = require("fastmcp");
-    import_zod = require("zod");
-    init_reddit_client();
-    init_formatters();
-    import_dotenv = __toESM(require("dotenv"));
-    import_dotenv.default.config();
-    server = new import_fastmcp.FastMCP({
-      name: "reddit-mcp-server",
-      version: "1.1.0",
-      instructions: `A comprehensive Reddit MCP server that provides tools for interacting with Reddit API.
-  
-Available capabilities:
-- Fetch Reddit posts, comments, and user information
-- Get subreddit details and statistics  
-- Search Reddit content across posts and subreddits
-- Create posts and reply to posts/comments (with authentication)
-- Analyze engagement metrics and community insights
-
-For write operations (posting, replying), ensure REDDIT_USERNAME and REDDIT_PASSWORD are configured.`,
-      // Optional OAuth configuration for HTTP transport
-      ...process.env.OAUTH_ENABLED === "true" && {
-        authenticate: async (request) => {
-          const authHeader = request.headers.authorization;
-          const expectedToken = process.env.OAUTH_TOKEN;
-          if (!expectedToken) {
-            const token2 = Array.from(
-              { length: 32 },
-              () => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".charAt(Math.floor(Math.random() * 62))
-            ).join("");
-            console.log(`[Auth] Generated OAuth token: ${token2}`);
-            throw new Response(
-              JSON.stringify({
-                error: "No OAuth token configured",
-                generatedToken: token2
-              }),
-              {
-                status: 401,
-                headers: { "Content-Type": "application/json" }
-              }
-            );
-          }
-          if (!(authHeader == null ? void 0 : authHeader.startsWith("Bearer "))) {
-            throw new Response(null, {
-              status: 401,
-              statusText: "Missing or invalid Authorization header"
-            });
-          }
-          const token = authHeader.slice(7);
-          if (token !== expectedToken) {
-            throw new Response(null, {
-              status: 403,
-              statusText: "Invalid token"
-            });
-          }
-          return { authenticated: true };
-        }
-      }
-    });
-    server.addTool({
-      name: "test_reddit_mcp_server",
-      description: "Test the Reddit MCP Server connection and configuration",
-      parameters: import_zod.z.object({}),
-      execute: async () => {
-        const client = getRedditClient();
-        const hasAuth = client ? "\u2713" : "\u2717";
-        const hasWriteAccess = process.env.REDDIT_USERNAME && process.env.REDDIT_PASSWORD ? "\u2713" : "\u2717";
-        return `Reddit MCP Server Status:
-- Server: \u2713 Running
-- Reddit Client: ${hasAuth} ${client ? "Initialized" : "Not initialized"}  
-- Write Access: ${hasWriteAccess} ${hasWriteAccess === "\u2713" ? "Available" : "Read-only mode"}
-- Version: 1.1.0
-
-Ready to handle Reddit API requests!`;
-      }
-    });
-    server.addTool({
-      name: "get_user_info",
-      description: "Get detailed information about a Reddit user including karma, account status, and activity analysis",
-      parameters: import_zod.z.object({
-        username: import_zod.z.string().describe("The Reddit username (without u/ prefix)")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const user = await client.getUser(args2.username);
-        const formattedUser = formatUserInfo(user);
-        return `# User Information: u/${formattedUser.username}
-
-## Profile Overview
-- Username: u/${formattedUser.username}
-- Karma:
-  - Comment Karma: ${formattedUser.karma.commentKarma.toLocaleString()}
-  - Post Karma: ${formattedUser.karma.postKarma.toLocaleString()}
-  - Total Karma: ${formattedUser.karma.totalKarma.toLocaleString()}
-- Account Status: ${formattedUser.accountStatus.join(", ")}
-- Account Created: ${formattedUser.accountCreated}
-- Profile URL: ${formattedUser.profileUrl}
-
-## Activity Analysis
-- ${formattedUser.activityAnalysis.replace(/\n  - /g, "\n- ")}
-
-## Recommendations
-- ${formattedUser.recommendations.replace(/\n {2}- /g, "\n- ")}`;
-      }
-    });
-    server.addTool({
-      name: "get_user_posts",
-      description: "Get recent posts by a Reddit user with sorting and filtering options",
-      parameters: import_zod.z.object({
-        username: import_zod.z.string().describe("The Reddit username (without u/ prefix)"),
-        sort: import_zod.z.enum(["new", "hot", "top"]).default("new").describe("Sort order for posts"),
-        time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("all").describe("Time filter for top posts"),
-        limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of posts to retrieve")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const posts = await client.getUserPosts(args2.username, {
-          sort: args2.sort,
-          timeFilter: args2.time_filter,
-          limit: args2.limit
-        });
-        if (posts.length === 0) {
-          return `No posts found for u/${args2.username} with the specified filters.`;
-        }
-        const postSummaries = posts.map((post, index) => {
-          const flags = [...post.over18 ? ["**NSFW**"] : [], ...post.spoiler ? ["**Spoiler**"] : []];
-          return `### ${index + 1}. ${post.title} ${flags.join(" ")}
-- Subreddit: r/${post.subreddit}
-- Score: ${post.score.toLocaleString()} (${(post.upvoteRatio * 100).toFixed(1)}% upvoted)
-- Comments: ${post.numComments.toLocaleString()}
-- Posted: ${new Date(post.createdUtc * 1e3).toLocaleString()}
-- Link: https://reddit.com${post.permalink}`;
-        }).join("\n\n");
-        return `# Posts by u/${args2.username} (${args2.sort} - ${args2.time_filter})
-
-${postSummaries}`;
-      }
-    });
-    server.addTool({
-      name: "get_user_comments",
-      description: "Get recent comments by a Reddit user with sorting and filtering options",
-      parameters: import_zod.z.object({
-        username: import_zod.z.string().describe("The Reddit username (without u/ prefix)"),
-        sort: import_zod.z.enum(["new", "hot", "top"]).default("new").describe("Sort order for comments"),
-        time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("all").describe("Time filter for top comments"),
-        limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of comments to retrieve")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const comments = await client.getUserComments(args2.username, {
-          sort: args2.sort,
-          timeFilter: args2.time_filter,
-          limit: args2.limit
-        });
-        if (comments.length === 0) {
-          return `No comments found for u/${args2.username} with the specified filters.`;
-        }
-        const commentSummaries = comments.map((comment, index) => {
-          const truncatedBody = comment.body.length > 300 ? comment.body.substring(0, 300) + "..." : comment.body;
-          const flags = [...comment.edited ? ["*(edited)*"] : [], ...comment.isSubmitter ? ["**OP**"] : []];
-          return `### ${index + 1}. Comment ${flags.join(" ")}
-In r/${comment.subreddit} on "${comment.submissionTitle}"
-
-> ${truncatedBody}
-
-- Score: ${comment.score.toLocaleString()}
-- Posted: ${new Date(comment.createdUtc * 1e3).toLocaleString()}
-- Link: https://reddit.com${comment.permalink}`;
-        }).join("\n\n");
-        return `# Comments by u/${args2.username} (${args2.sort} - ${args2.time_filter})
-
-${commentSummaries}`;
-      }
-    });
-    server.addTool({
-      name: "get_reddit_post",
-      description: "Get detailed information about a specific Reddit post including content, stats, and engagement analysis",
-      parameters: import_zod.z.object({
-        subreddit: import_zod.z.string().describe("The subreddit name (without r/ prefix)"),
-        post_id: import_zod.z.string().describe("The Reddit post ID")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const post = await client.getPost(args2.post_id, args2.subreddit);
-        const formattedPost = formatPostInfo(post);
-        return `# Post from r/${formattedPost.subreddit}
-
-## Post Details
-- Title: ${formattedPost.title}
-- Type: ${formattedPost.type}
-- Author: u/${formattedPost.author}
-
-## Content
-${formattedPost.content}
-
-## Stats
-- Score: ${formattedPost.stats.score.toLocaleString()}
-- Upvote Ratio: ${(formattedPost.stats.upvoteRatio * 100).toFixed(1)}%
-- Comments: ${formattedPost.stats.comments.toLocaleString()}
-
-## Metadata
-- Posted: ${formattedPost.metadata.posted}
-- Flags: ${formattedPost.metadata.flags.length ? formattedPost.metadata.flags.join(", ") : "None"}
-- Flair: ${formattedPost.metadata.flair}
-
-## Links
-- Full Post: ${formattedPost.links.fullPost}
-- Short Link: ${formattedPost.links.shortLink}
-
-## Engagement Analysis
-- ${formattedPost.engagementAnalysis.replace(/\n  - /g, "\n- ")}
-
-## Best Time to Engage
-${formattedPost.bestTimeToEngage}`;
-      }
-    });
-    server.addTool({
-      name: "get_top_posts",
-      description: "Get top posts from a subreddit or from the Reddit home feed",
-      parameters: import_zod.z.object({
-        subreddit: import_zod.z.string().optional().describe("The subreddit name (without r/ prefix). Leave empty for home feed"),
-        time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("week").describe("Time period for top posts"),
-        limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of posts to retrieve")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const posts = await client.getTopPosts(args2.subreddit || "", args2.time_filter, args2.limit);
-        if (posts.length === 0) {
-          const location2 = args2.subreddit ? `r/${args2.subreddit}` : "home feed";
-          return `No posts found in ${location2} for the specified time period.`;
-        }
-        const formattedPosts = posts.map(formatPostInfo);
-        const postSummaries = formattedPosts.map(
-          (post, index) => `### ${index + 1}. ${post.title}
-- Author: u/${post.author}
-- Score: ${post.stats.score.toLocaleString()} (${(post.stats.upvoteRatio * 100).toFixed(1)}% upvoted)
-- Comments: ${post.stats.comments.toLocaleString()}
-- Posted: ${post.metadata.posted}
-- Link: ${post.links.shortLink}`
-        ).join("\n\n");
-        const location = args2.subreddit ? `r/${args2.subreddit}` : "Home Feed";
-        return `# Top Posts from ${location} (${args2.time_filter})
-
-${postSummaries}`;
-      }
-    });
-    server.addTool({
-      name: "get_subreddit_info",
-      description: "Get detailed information about a subreddit including description, stats, and community analysis",
-      parameters: import_zod.z.object({
-        subreddit_name: import_zod.z.string().describe("The subreddit name (without r/ prefix)")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const subreddit = await client.getSubredditInfo(args2.subreddit_name);
-        const formattedSubreddit = formatSubredditInfo(subreddit);
-        return `# Subreddit Information: r/${formattedSubreddit.name}
-
-## Overview
-- Name: r/${formattedSubreddit.name}
-- Title: ${formattedSubreddit.title}
-- Subscribers: ${formattedSubreddit.stats.subscribers.toLocaleString()}
-- Active Users: ${typeof formattedSubreddit.stats.activeUsers === "number" ? formattedSubreddit.stats.activeUsers.toLocaleString() : formattedSubreddit.stats.activeUsers}
-
-## Description
-${formattedSubreddit.description.short}
-
-## Detailed Description
-${formattedSubreddit.description.full}
-
-## Metadata
-- Created: ${formattedSubreddit.metadata.created}
-- Flags: ${formattedSubreddit.metadata.flags.join(", ")}
-
-## Links
-- Subreddit: ${formattedSubreddit.links.subreddit}
-- Wiki: ${formattedSubreddit.links.wiki}
-
-## Community Analysis
-- ${formattedSubreddit.communityAnalysis.replace(/\n  - /g, "\n- ")}
-
-## Engagement Tips
-- ${formattedSubreddit.engagementTips.replace(/\n  - /g, "\n- ")}`;
-      }
-    });
-    server.addTool({
-      name: "get_trending_subreddits",
-      description: "Get a list of currently trending subreddits",
-      parameters: import_zod.z.object({}),
-      execute: async () => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        const trendingSubreddits = await client.getTrendingSubreddits();
-        return `# Trending Subreddits
-
-${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}`;
-      }
-    });
-    server.addTool({
-      name: "search_reddit",
-      description: "Search Reddit for posts and content across subreddits",
-      parameters: import_zod.z.object({
-        query: import_zod.z.string().describe("Search query"),
-        subreddit: import_zod.z.string().optional().describe("Limit search to specific subreddit (without r/ prefix)"),
-        sort: import_zod.z.enum(["relevance", "hot", "top", "new", "comments"]).default("relevance").describe("Sort order"),
-        time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("all").describe("Time filter"),
-        limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of results"),
-        type: import_zod.z.enum(["link", "sr", "user"]).default("link").describe("Type of content to search")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        if (!args2.query || args2.query.trim() === "") {
-          throw new Error("Search query cannot be empty");
-        }
-        const posts = await client.searchReddit(args2.query, {
-          subreddit: args2.subreddit,
-          sort: args2.sort,
-          timeFilter: args2.time_filter,
-          limit: args2.limit,
-          type: args2.type
-        });
-        if (posts.length === 0) {
-          const searchLocation2 = args2.subreddit ? ` in r/${args2.subreddit}` : "";
-          return `No results found for "${args2.query}"${searchLocation2}.`;
-        }
-        const searchResults = posts.map((post, index) => {
-          const flags = [...post.over18 ? ["**NSFW**"] : [], ...post.spoiler ? ["**Spoiler**"] : []];
-          return `### ${index + 1}. ${post.title} ${flags.join(" ")}
-- Subreddit: r/${post.subreddit}
-- Author: u/${post.author}
-- Score: ${post.score.toLocaleString()} (${(post.upvoteRatio * 100).toFixed(1)}% upvoted)
-- Comments: ${post.numComments.toLocaleString()}
-- Posted: ${new Date(post.createdUtc * 1e3).toLocaleString()}
-- Link: https://reddit.com${post.permalink}`;
-        }).join("\n\n");
-        const searchLocation = args2.subreddit ? ` in r/${args2.subreddit}` : "";
-        return `# Reddit Search Results for: "${args2.query}"${searchLocation}
-
-Sorted by: ${args2.sort} | Time: ${args2.time_filter} | Type: ${args2.type}
-
-${searchResults}`;
-      }
-    });
-    server.addTool({
-      name: "get_post_comments",
-      description: "Get comments from a specific Reddit post",
-      parameters: import_zod.z.object({
-        post_id: import_zod.z.string().describe("The Reddit post ID"),
-        subreddit: import_zod.z.string().describe("The subreddit name (without r/ prefix)"),
-        sort: import_zod.z.enum(["best", "top", "new", "controversial", "old", "qa"]).default("best").describe("Comment sort order"),
-        limit: import_zod.z.number().min(1).max(500).default(100).describe("Maximum number of comments to retrieve")
-      }),
-      execute: async (args2) => {
-        const client = getRedditClient();
-        if (!client) {
-          throw new Error("Reddit client not initialized");
-        }
-        if (!args2.post_id || !args2.subreddit) {
-          throw new Error("post_id and subreddit are required");
-        }
-        const data = await client.getPostComments(args2.post_id, args2.subreddit, {
-          sort: args2.sort,
-          limit: args2.limit
-        });
-        const post = data.post;
-        const comments = data.comments;
-        let response = `# Comments for: ${post.title}
-
-**Post by u/${post.author} in r/${post.subreddit}**
-- Score: ${post.score.toLocaleString()} | Comments: ${post.numComments.toLocaleString()}
-- Posted: ${new Date(post.createdUtc * 1e3).toLocaleString()}
-
----
-
-`;
-        if (comments.length === 0) {
-          response += "No comments found for this post.";
-          return response;
-        }
-        const commentSummaries = comments.map((comment) => {
-          const indent = "\u2514\u2500".repeat(Math.min(comment.depth || 0, 3));
-          const authorBadge = comment.isSubmitter ? " **[OP]**" : "";
-          const editedBadge = comment.edited ? " *(edited)*" : "";
-          return `${indent} **u/${comment.author}**${authorBadge}${editedBadge} (${comment.score.toLocaleString()} points)
-
-${comment.body}
-
----`;
-        }).join("\n\n");
-        response += commentSummaries;
-        return response;
-      }
-    });
-    process.on("SIGINT", async () => {
-      console.error("[Shutdown] Shutting down Reddit MCP Server...");
-      process.exit(0);
-    });
-    process.on("SIGTERM", async () => {
-      console.error("[Shutdown] Shutting down Reddit MCP Server...");
-      process.exit(0);
-    });
-    main().catch(console.error);
-  }
-});
-
-// 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);
+const require_chunk = require('./chunk-kSYXY2_d.js');
+let fs = require("fs");
+fs = require_chunk.__toESM(fs);
+let path = require("path");
+path = require_chunk.__toESM(path);
+
+//#region src/bin.ts
+const packageJsonPath = path.default.join(__dirname, "..", "package.json");
+const packageJson = JSON.parse(fs.default.readFileSync(packageJsonPath, "utf-8"));
+if (!process.env.TRANSPORT_TYPE) process.env.TRANSPORT_TYPE = "stdio";
+const args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
-  console.log(packageJson.version);
-  process.exit(0);
+	console.log(packageJson.version);
+	process.exit(0);
 }
-main2().then();
+main().then();
 if (args.includes("--help") || args.includes("-h")) {
-  console.log(`
+	console.log(`
 Reddit MCP Server v${packageJson.version}
 
 Usage: reddit-mcp-server [options]
@@ -1261,8 +34,11 @@ Environment Variables:
 
 For more information, visit: https://github.com/jordanburke/reddit-mcp-server
 `);
-  process.exit(0);
+	process.exit(0);
 }
-async function main2() {
-  await Promise.resolve().then(() => (init_src(), src_exports));
+async function main() {
+	await Promise.resolve().then(() => require("./index.js"));
 }
+
+//#endregion
+//# sourceMappingURL=bin.js.map