reddit-mcp-server 1.1.0 → 1.1.1

package/dist/bin.js

@@ -9,10 +9,6 @@ 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))
@@ -30,66 +26,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.3_typescript@5.8.3/node_modules/tsup/assets/cjs_shims.js
+// 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.3_typescript@5.8.3/node_modules/tsup/assets/cjs_shims.js"() {
+  "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/middleware/auth.ts
-var auth_exports = {};
-__export(auth_exports, {
-  createAuthMiddleware: () => createAuthMiddleware,
-  generateRandomToken: () => generateRandomToken
-});
-function createAuthMiddleware(config = {}) {
-  return async (c, next) => {
-    if (!config.enabled || !config.token) {
-      return next();
-    }
-    const authHeader = c.req.header("Authorization");
-    if (!authHeader) {
-      throw new import_http_exception.HTTPException(401, {
-        message: "Authorization header required"
-      });
-    }
-    const [scheme, token] = authHeader.split(" ");
-    if (scheme !== "Bearer") {
-      throw new import_http_exception.HTTPException(401, {
-        message: "Invalid authorization scheme. Use 'Bearer <token>'"
-      });
-    }
-    if (!token) {
-      throw new import_http_exception.HTTPException(401, {
-        message: "Bearer token required"
-      });
-    }
-    if (token !== config.token) {
-      throw new import_http_exception.HTTPException(403, {
-        message: "Invalid token"
-      });
-    }
-    return next();
-  };
-}
-function generateRandomToken(length = 32) {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}
-var import_http_exception;
-var init_auth = __esm({
-  "src/middleware/auth.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_http_exception = require("hono/http-exception");
-  }
-});
-
 // src/client/reddit-client.ts
 function initializeRedditClient(config) {
   redditClient = new RedditClient(config);
@@ -724,21 +667,6 @@ function getSubredditEngagementTips(subreddit) {
   }
   return tips.length ? tips.join("\n  - ") : "Regular engagement recommended to maintain community presence";
 }
-function analyzeCommentImpact(score, isEdited, isOp) {
-  const insights = [];
-  if (score > 100) {
-    insights.push("Highly upvoted comment with significant community agreement");
-  } else if (score < 0) {
-    insights.push("Controversial or contested viewpoint");
-  }
-  if (isEdited) {
-    insights.push("Refined for clarity or accuracy");
-  }
-  if (isOp) {
-    insights.push("Author's perspective adds context to original post");
-  }
-  return insights.length ? insights.join("\n  - ") : "Standard engagement with discussion";
-}
 function formatUserInfo(user) {
   const status = [];
   if (user.isMod) status.push("Moderator");
@@ -819,44 +747,6 @@ function formatSubredditInfo(subreddit) {
     engagementTips: getSubredditEngagementTips(subreddit)
   };
 }
-function formatCommentInfo(comment) {
-  const flags = [];
-  if (comment.edited) flags.push("Edited");
-  if (comment.isSubmitter) flags.push("OP");
-  return {
-    author: comment.author,
-    content: comment.body.length > 300 ? comment.body.substring(0, 297) + "..." : comment.body,
-    stats: {
-      score: comment.score,
-      controversiality: comment.controversiality
-    },
-    context: {
-      subreddit: comment.subreddit,
-      thread: comment.submissionTitle
-    },
-    metadata: {
-      posted: formatTimestamp(comment.createdUtc),
-      flags: flags.length ? flags : ["None"]
-    },
-    link: `https://reddit.com${comment.permalink}`,
-    commentAnalysis: analyzeCommentImpact(comment.score, comment.edited, comment.isSubmitter)
-  };
-}
-function formatPost(post) {
-  return {
-    title: post.title,
-    author: post.author,
-    subreddit: post.subreddit,
-    score: post.score,
-    upvoteRatio: Math.round(post.upvoteRatio * 100),
-    numComments: post.numComments,
-    createdAt: formatTimestamp(post.createdUtc),
-    selftext: post.selftext,
-    permalink: post.permalink,
-    nsfw: post.over18,
-    spoiler: post.spoiler
-  };
-}
 var init_formatters = __esm({
   "src/utils/formatters.ts"() {
     "use strict";
@@ -864,22 +754,144 @@ var init_formatters = __esm({
   }
 });
 
-// src/tools/user-tools.ts
-async function getUserInfo(params) {
-  const { username } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
+// 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 {
-    const user = await client.getUser(username);
-    const formattedUser = formatUserInfo(user);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# User Information: u/${formattedUser.username}
+    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}
@@ -895,122 +907,99 @@ async function getUserInfo(params) {
 - ${formattedUser.activityAnalysis.replace(/\n  - /g, "\n- ")}
 
 ## Recommendations
-- ${formattedUser.recommendations.replace(/\n  - /g, "\n- ")}
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user data: ${String(error)}`);
-  }
-}
-async function getUserPosts(params) {
-  const { username, sort = "new", time_filter = "all", limit = 10 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const posts = await client.getUserPosts(username, {
-      sort,
-      timeFilter: time_filter,
-      limit
+- ${formattedUser.recommendations.replace(/\n {2}- /g, "\n- ")}`;
+      }
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Posts by u/${username}
-
-## Sort: ${sort} | Time: ${time_filter} | Count: ${posts.length}
-
-${posts.map((post, index) => {
-            const date = new Date(post.createdUtc * 1e3).toLocaleString();
-            const selftext = post.selftext ? `
-${post.selftext.substring(0, 200)}${post.selftext.length > 200 ? "..." : ""}
-` : "";
-            return `### ${index + 1}. ${post.title}
-- Subreddit: r/${post.subreddit}
-- Score: ${post.score} (${Math.round(post.upvoteRatio * 100)}% upvoted)
-- Comments: ${post.numComments}
-- Posted: ${date}
-${selftext}
-- Link: https://reddit.com${post.permalink}
-${post.over18 ? "- **NSFW**" : ""}
-${post.spoiler ? "- **Spoiler**" : ""}`;
-          }).join("\n\n---\n\n")}`
+    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");
         }
-      ]
-    };
-  } catch (error) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user posts: ${String(error)}`);
-  }
-}
-async function getUserComments(params) {
-  const { username, sort = "new", time_filter = "all", limit = 10 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const comments = await client.getUserComments(username, {
-      sort,
-      timeFilter: time_filter,
-      limit
+        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}`;
+      }
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Comments by u/${username}
+    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}"
 
-## Sort: ${sort} | Time: ${time_filter} | Count: ${comments.length}
+> ${truncatedBody}
 
-${comments.map((comment, index) => {
-            const date = new Date(comment.createdUtc * 1e3).toLocaleString();
-            const edited = comment.edited ? " *(edited)*" : "";
-            const body = comment.body.length > 300 ? comment.body.substring(0, 300) + "..." : comment.body;
-            return `### ${index + 1}. In r/${comment.subreddit} on "${comment.submissionTitle}"
-- Score: ${comment.score} points
-- Posted: ${date}${edited}
-- Link: https://reddit.com${comment.permalink}
+- 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})
 
-${body}`;
-          }).join("\n\n---\n\n")}`
+${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");
         }
-      ]
-    };
-  } catch (error) {
-    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
-async function getRedditPost(params) {
-  const { subreddit, post_id } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const post = await client.getPost(post_id, subreddit);
-    const formattedPost = formatPostInfo(post);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Post from r/${formattedPost.subreddit}
+        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}
@@ -1038,139 +1027,56 @@ ${formattedPost.content}
 - ${formattedPost.engagementAnalysis.replace(/\n  - /g, "\n- ")}
 
 ## Best Time to Engage
-${formattedPost.bestTimeToEngage}
-          `
+${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");
         }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to fetch post data: ${String(error)}`);
-  }
-}
-async function getTopPosts(params) {
-  const { subreddit, time_filter = "week", limit = 10 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const posts = await client.getTopPosts(subreddit, time_filter, limit);
-    const formattedPosts = posts.map(formatPostInfo);
-    const postSummaries = formattedPosts.map(
-      (post, index) => `
-### ${index + 1}. ${post.title}
+        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");
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Top Posts from r/${subreddit} (${time_filter})
+- 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}
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to fetch top posts: ${String(error)}`);
-  }
-}
-async function createPost(params) {
-  const { subreddit, title, content, is_self = true } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const post = await client.createPost(subreddit, title, content, is_self);
-    const formattedPost = formatPostInfo(post);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Post Created Successfully
-
-## Post Details
-- Title: ${formattedPost.title}
-- Subreddit: r/${formattedPost.subreddit}
-- Type: ${formattedPost.type}
-- Link: ${formattedPost.links.fullPost}
-
-Your post has been successfully submitted to r/${formattedPost.subreddit}.
-          `
+${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");
         }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to create post: ${String(error)}`);
-  }
-}
-async function replyToPost(params) {
-  const { post_id, content } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const comment = await client.replyToPost(post_id, content);
-    const formattedComment = formatCommentInfo(comment);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Reply Posted Successfully
-
-## Comment Details
-- Author: u/${formattedComment.author}
-- Subreddit: r/${formattedComment.context.subreddit}
-- Thread: ${formattedComment.context.thread}
-- Link: ${formattedComment.link}
-
-Your reply has been successfully posted.
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to reply to post: ${String(error)}`);
-  }
-}
-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
-async function getSubredditInfo(params) {
-  const { subreddit_name } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const subreddit = await client.getSubredditInfo(subreddit_name);
-    const formattedSubreddit = formatSubredditInfo(subreddit);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Subreddit Information: r/${formattedSubreddit.name}
+        const subreddit = await client.getSubredditInfo(args2.subreddit_name);
+        const formattedSubreddit = formatSubredditInfo(subreddit);
+        return `# Subreddit Information: r/${formattedSubreddit.name}
 
 ## Overview
 - Name: r/${formattedSubreddit.name}
@@ -1196,636 +1102,131 @@ ${formattedSubreddit.description.full}
 - ${formattedSubreddit.communityAnalysis.replace(/\n  - /g, "\n- ")}
 
 ## Engagement Tips
-- ${formattedSubreddit.engagementTips.replace(/\n  - /g, "\n- ")}
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, `Failed to fetch subreddit data: ${String(error)}`);
-  }
-}
-async function getTrendingSubreddits() {
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const trendingSubreddits = await client.getTrendingSubreddits();
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Trending Subreddits
-
-${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}
-          `
+- ${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");
         }
-      ]
-    };
-  } catch (error) {
-    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");
-  }
-});
+        const trendingSubreddits = await client.getTrendingSubreddits();
+        return `# Trending Subreddits
 
-// src/tools/search-tools.ts
-async function searchReddit(params) {
-  const { query, subreddit, sort = "relevance", time_filter = "all", limit = 10, type = "link" } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types4.McpError(import_types4.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  if (!query || query.trim().length === 0) {
-    throw new import_types4.McpError(import_types4.ErrorCode.InvalidParams, "Search query cannot be empty");
-  }
-  try {
-    const posts = await client.searchReddit(query, {
-      subreddit,
-      sort,
-      timeFilter: time_filter,
-      limit,
-      type
+${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}`;
+      }
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Reddit Search Results for: "${query}"${subreddit ? ` in r/${subreddit}` : ""}
-
-## Search Parameters
-- Sort: ${sort}
-- Time Filter: ${time_filter}
-- Type: ${type}
-- Results: ${posts.length}
-
-${posts.map((post, index) => {
-            const formatted = formatPost(post);
-            return `### ${index + 1}. ${formatted.title}
-- Author: u/${formatted.author}
-- Subreddit: r/${formatted.subreddit}
-- Score: ${formatted.score} (${formatted.upvoteRatio}% upvoted)
-- Comments: ${formatted.numComments}
-- Posted: ${formatted.createdAt}
-${formatted.selftext ? `
-${formatted.selftext.substring(0, 200)}${formatted.selftext.length > 200 ? "..." : ""}
-` : ""}
-- Link: https://reddit.com${formatted.permalink}
-${formatted.nsfw ? "- **NSFW**" : ""}
-${formatted.spoiler ? "- **Spoiler**" : ""}
-`;
-          }).join("\n")}`
+    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");
         }
-      ]
-    };
-  } catch (error) {
-    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");
-  }
-});
+        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}
 
-// src/tools/comment-tools.ts
-async function getPostComments(params) {
-  const { post_id, subreddit, sort = "best", limit = 100 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types5.McpError(import_types5.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  if (!post_id || !subreddit) {
-    throw new import_types5.McpError(import_types5.ErrorCode.InvalidParams, "post_id and subreddit are required");
-  }
-  try {
-    const { post, comments } = await client.getPostComments(post_id, subreddit, {
-      sort,
-      limit
-    });
-    const formattedPost = formatPost(post);
-    const formatComment = (comment) => {
-      const edited = comment.edited ? " *(edited)*" : "";
-      const submitter = comment.isSubmitter ? " **[OP]**" : "";
-      const depth = comment.depth || 0;
-      const prefix = "  ".repeat(depth) + (depth > 0 ? "\u2514\u2500 " : "");
-      return `${prefix}**u/${comment.author}**${submitter} \u2022 ${comment.score} points \u2022 ${new Date(comment.createdUtc * 1e3).toLocaleString()}${edited}
-${prefix}${comment.body.split("\n").join(`
-${prefix}`)}`;
-    };
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Comments for: ${formattedPost.title}
+Sorted by: ${args2.sort} | Time: ${args2.time_filter} | Type: ${args2.type}
 
-## Post Details
-- Author: u/${formattedPost.author}
-- Subreddit: r/${formattedPost.subreddit}
-- Score: ${formattedPost.score} (${formattedPost.upvoteRatio}% upvoted)
-- Posted: ${formattedPost.createdAt}
-- Link: https://reddit.com${formattedPost.permalink}
+${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 Content
-${formattedPost.selftext || "[Link post - no text content]"}
+**Post by u/${post.author} in r/${post.subreddit}**
+- Score: ${post.score.toLocaleString()} | Comments: ${post.numComments.toLocaleString()}
+- Posted: ${new Date(post.createdUtc * 1e3).toLocaleString()}
 
-## Comments (${comments.length} loaded, sorted by ${sort})
+---
 
-${comments.map((comment) => formatComment(comment)).join("\n\n---\n\n")}`
+`;
+        if (comments.length === 0) {
+          response += "No comments found for this post.";
+          return response;
         }
-      ]
-    };
-  } catch (error) {
-    throw new import_types5.McpError(import_types5.ErrorCode.InternalError, `Failed to fetch comments: ${String(error)}`);
-  }
-}
-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");
-  }
-});
+        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)
 
-// 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();
-  }
-});
+${comment.body}
 
-// 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: {}
-            }
-          }
-        );
-        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
-                }
-              }
-            },
-            {
-              name: "get_reddit_post",
-              description: "Get a Reddit post",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  subreddit: {
-                    type: "string",
-                    description: "The subreddit to fetch posts from"
-                  },
-                  post_id: {
-                    type: "string",
-                    description: "The ID of the post to fetch"
-                  }
-                },
-                required: ["subreddit", "post_id"]
-              }
-            },
-            {
-              name: "get_top_posts",
-              description: "Get top posts from a subreddit",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  subreddit: {
-                    type: "string",
-                    description: "Name of the subreddit"
-                  },
-                  time_filter: {
-                    type: "string",
-                    description: "Time period to filter posts (e.g. 'day', 'week', 'month', 'year', 'all')",
-                    enum: ["day", "week", "month", "year", "all"],
-                    default: "week"
-                  },
-                  limit: {
-                    type: "integer",
-                    description: "Number of posts to fetch",
-                    default: 10
-                  }
-                },
-                required: ["subreddit"]
-              }
-            },
-            {
-              name: "get_user_info",
-              description: "Get information about a Reddit user",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  username: {
-                    type: "string",
-                    description: "The username of the Reddit user to get info for"
-                  }
-                },
-                required: ["username"]
-              }
-            },
-            {
-              name: "get_subreddit_info",
-              description: "Get information about a subreddit",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  subreddit_name: {
-                    type: "string",
-                    description: "Name of the subreddit"
-                  }
-                },
-                required: ["subreddit_name"]
-              }
-            },
-            {
-              name: "get_trending_subreddits",
-              description: "Get currently trending subreddits",
-              inputSchema: {
-                type: "object",
-                properties: {}
-              }
-            },
-            {
-              name: "create_post",
-              description: "Create a new post in a subreddit",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  subreddit: {
-                    type: "string",
-                    description: "Name of the subreddit to post in"
-                  },
-                  title: {
-                    type: "string",
-                    description: "Title of the post"
-                  },
-                  content: {
-                    type: "string",
-                    description: "Content of the post (text for self posts, URL for link posts)"
-                  },
-                  is_self: {
-                    type: "boolean",
-                    description: "Whether this is a self (text) post (true) or link post (false)",
-                    default: true
-                  }
-                },
-                required: ["subreddit", "title", "content"]
-              }
-            },
-            {
-              name: "reply_to_post",
-              description: "Post a reply to an existing Reddit post",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  post_id: {
-                    type: "string",
-                    description: "The ID of the post to reply to"
-                  },
-                  content: {
-                    type: "string",
-                    description: "The content of the reply"
-                  },
-                  subreddit: {
-                    type: "string",
-                    description: "The subreddit name if known (for validation)"
-                  }
-                },
-                required: ["post_id", "content"]
-              }
-            },
-            {
-              name: "search_reddit",
-              description: "Search for posts on Reddit",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  query: {
-                    type: "string",
-                    description: "The search query"
-                  },
-                  subreddit: {
-                    type: "string",
-                    description: "Search within a specific subreddit (optional)"
-                  },
-                  sort: {
-                    type: "string",
-                    description: "Sort order: relevance, hot, top, new, comments",
-                    enum: ["relevance", "hot", "top", "new", "comments"],
-                    default: "relevance"
-                  },
-                  time_filter: {
-                    type: "string",
-                    description: "Time filter: hour, day, week, month, year, all",
-                    enum: ["hour", "day", "week", "month", "year", "all"],
-                    default: "all"
-                  },
-                  limit: {
-                    type: "number",
-                    description: "Maximum number of results to return",
-                    minimum: 1,
-                    maximum: 100,
-                    default: 10
-                  },
-                  type: {
-                    type: "string",
-                    description: "Type of content: link (posts), sr (subreddits), user (users)",
-                    enum: ["link", "sr", "user"],
-                    default: "link"
-                  }
-                },
-                required: ["query"]
-              }
-            },
-            {
-              name: "get_post_comments",
-              description: "Get comments for a specific Reddit post",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  post_id: {
-                    type: "string",
-                    description: "The ID of the post"
-                  },
-                  subreddit: {
-                    type: "string",
-                    description: "The subreddit where the post is located"
-                  },
-                  sort: {
-                    type: "string",
-                    description: "Comment sort order: best, top, new, controversial, old, qa",
-                    enum: ["best", "top", "new", "controversial", "old", "qa"],
-                    default: "best"
-                  },
-                  limit: {
-                    type: "number",
-                    description: "Maximum number of comments to load",
-                    minimum: 1,
-                    maximum: 500,
-                    default: 100
-                  }
-                },
-                required: ["post_id", "subreddit"]
-              }
-            },
-            {
-              name: "get_user_posts",
-              description: "Get posts submitted by a specific user",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  username: {
-                    type: "string",
-                    description: "The username to get posts for"
-                  },
-                  sort: {
-                    type: "string",
-                    description: "Sort order: new, hot, top, controversial",
-                    enum: ["new", "hot", "top", "controversial"],
-                    default: "new"
-                  },
-                  time_filter: {
-                    type: "string",
-                    description: "Time filter for top/controversial: hour, day, week, month, year, all",
-                    enum: ["hour", "day", "week", "month", "year", "all"],
-                    default: "all"
-                  },
-                  limit: {
-                    type: "number",
-                    description: "Maximum number of posts to return",
-                    minimum: 1,
-                    maximum: 100,
-                    default: 10
-                  }
-                },
-                required: ["username"]
-              }
-            },
-            {
-              name: "get_user_comments",
-              description: "Get comments made by a specific user",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  username: {
-                    type: "string",
-                    description: "The username to get comments for"
-                  },
-                  sort: {
-                    type: "string",
-                    description: "Sort order: new, hot, top, controversial",
-                    enum: ["new", "hot", "top", "controversial"],
-                    default: "new"
-                  },
-                  time_filter: {
-                    type: "string",
-                    description: "Time filter for top/controversial: hour, day, week, month, year, all",
-                    enum: ["hour", "day", "week", "month", "year", "all"],
-                    default: "all"
-                  },
-                  limit: {
-                    type: "number",
-                    description: "Maximum number of comments to return",
-                    minimum: 1,
-                    maximum: 100,
-                    default: 10
-                  }
-                },
-                required: ["username"]
-              }
-            }
-          ]
-        }));
-        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;
-          }
-        });
-      }
-      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)"
-        });
+---`;
+        }).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);
   }
 });
 
@@ -1840,26 +1241,7 @@ if (args.includes("--version") || args.includes("-v")) {
   console.log(packageJson.version);
   process.exit(0);
 }
-if (args.includes("--generate-token")) {
-  async function generateToken() {
-    const { generateRandomToken: generateRandomToken2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
-    const token = generateRandomToken2(32);
-    console.log(`Generated OAuth token: ${token}`);
-    console.log(`
-To use this token, set the environment variable:`);
-    console.log(`export OAUTH_TOKEN="${token}"`);
-    console.log(`export OAUTH_ENABLED=true`);
-    console.log(`
-Then start the HTTP server with: pnpm serve`);
-    process.exit(0);
-  }
-  generateToken().catch((error) => {
-    console.error("Failed to generate token:", error);
-    process.exit(1);
-  });
-} else {
-  main().then();
-}
+main2().then();
 if (args.includes("--help") || args.includes("-h")) {
   console.log(`
 Reddit MCP Server v${packageJson.version}
@@ -1869,7 +1251,6 @@ Usage: reddit-mcp-server [options]
 Options:
   -v, --version        Show version number
   -h, --help           Show help
-  --generate-token     Generate a secure OAuth token for HTTP server
 
 Environment Variables:
   REDDIT_CLIENT_ID      Reddit API client ID (required)
@@ -1878,19 +1259,10 @@ Environment Variables:
   REDDIT_PASSWORD       Reddit password (optional, for write operations)
   REDDIT_USER_AGENT     Custom user agent (optional)
 
-HTTP Server OAuth Variables:
-  OAUTH_ENABLED         Set to "true" to enable OAuth protection
-  OAUTH_TOKEN           Custom OAuth token (use --generate-token to create one)
-
 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);
-  });
+async function main2() {
+  await Promise.resolve().then(() => (init_src(), src_exports));
 }