reddit-mcp-server 1.1.0 → 1.1.2

package/dist/index.js

@@ -5,10 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,17 +21,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  RedditServer: () => RedditServer
-});
-module.exports = __toCommonJS(src_exports);
-var import_server = require("@modelcontextprotocol/sdk/server/index.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_types6 = require("@modelcontextprotocol/sdk/types.js");
+var import_fastmcp = require("fastmcp");
+var import_zod = require("zod");
 
 // src/client/reddit-client.ts
 var RedditClient = class {
@@ -90,7 +79,8 @@ var RedditClient = class {
       }
       const authUrl = "https://www.reddit.com/api/v1/access_token";
       const authData = new URLSearchParams();
-      if (this.username && this.password) {
+      const isUserAuth = !!(this.username && this.password);
+      if (isUserAuth) {
         authData.append("grant_type", "password");
         authData.append("username", this.username);
         authData.append("password", this.password);
@@ -108,13 +98,17 @@ var RedditClient = class {
         body: authData.toString()
       });
       if (!response.ok) {
-        throw new Error(`Authentication failed: ${response.status}`);
+        const statusText = response.statusText || "Unknown Error";
+        throw new Error(`Authentication failed: ${response.status} ${statusText}`);
       }
       const data = await response.json();
       this.accessToken = data.access_token;
       this.tokenExpiry = now + data.expires_in * 1e3;
       this.authenticated = true;
-    } catch {
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
       throw new Error("Failed to authenticate with Reddit API");
     }
   }
@@ -272,6 +266,7 @@ var RedditClient = class {
     }
   }
   async createPost(subreddit, title, content, isSelf = true) {
+    var _a, _b, _c, _d, _e, _f;
     await this.authenticate();
     if (!this.username || !this.password) {
       throw new Error("User authentication required for posting");
@@ -283,6 +278,7 @@ var RedditClient = class {
       params.append("kind", kind);
       params.append("title", title);
       params.append(isSelf ? "text" : "url", content);
+      params.append("api_type", "json");
       const response = await this.makeRequest("/api/submit", {
         method: "POST",
         headers: {
@@ -291,17 +287,33 @@ var RedditClient = class {
         body: params.toString()
       });
       if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
+        const errorText = await response.text();
+        console.error(`[Reddit API] Create post failed: ${response.status} ${response.statusText}`);
+        console.error(`[Reddit API] Error response: ${errorText}`);
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
       }
       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");
+      console.error(`[Reddit API] Create post response:`, JSON.stringify(json, null, 2));
+      if (((_a = json.json) == null ? void 0 : _a.errors) && json.json.errors.length > 0) {
+        const errors = json.json.errors.map((e) => e.join(": ")).join(", ");
+        console.error(`[Reddit API] Post creation errors: ${errors}`);
+        throw new Error(`Reddit API errors: ${errors}`);
       }
-    } catch {
-      throw new Error(`Failed to create post in ${subreddit}`);
+      const postId = ((_c = (_b = json.json) == null ? void 0 : _b.data) == null ? void 0 : _c.id) || ((_f = (_e = (_d = json.json) == null ? void 0 : _d.data) == null ? void 0 : _e.name) == null ? void 0 : _f.replace("t3_", ""));
+      if (!postId) {
+        console.error(`[Reddit API] No post ID in response`);
+        throw new Error("No post ID returned from Reddit");
+      }
+      console.error(`[Reddit API] Post created with ID: ${postId}`);
+      return await this.getPost(postId, subreddit);
+    } catch (error) {
+      console.error(`[Reddit API] Create post exception:`, error);
+      if (error instanceof Error && error.message.includes("HTTP")) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to create post in ${subreddit}: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
   async checkPostExists(postId) {
@@ -329,6 +341,7 @@ var RedditClient = class {
       const params = new URLSearchParams();
       params.append("thing_id", `t3_${postId}`);
       params.append("text", content);
+      params.append("api_type", "json");
       const response = await this.makeRequest("/api/comment", {
         method: "POST",
         headers: {
@@ -337,26 +350,126 @@ var RedditClient = class {
         body: params.toString()
       });
       if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
+        const errorText = await response.text();
+        console.error(`[Reddit API] Reply to post failed: ${response.status} ${response.statusText}`);
+        console.error(`[Reddit API] Error response: ${errorText}`);
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
       }
-      const commentData = await response.json();
-      return {
-        id: commentData.id,
-        author: this.username,
-        body: content,
-        score: 1,
-        controversiality: 0,
-        subreddit: commentData.subreddit,
-        submissionTitle: commentData.link_title,
-        createdUtc: Date.now() / 1e3,
-        edited: false,
-        isSubmitter: false,
-        permalink: commentData.permalink
-      };
-    } catch {
-      throw new Error(`Failed to reply to post ${postId}`);
+      const json = await response.json();
+      console.error(`[Reddit API] Reply response:`, JSON.stringify(json, null, 2));
+      if (json.json && json.json.data && json.json.data.things) {
+        const commentData = json.json.data.things[0].data;
+        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
+        };
+      } else if (json.json && json.json.errors && json.json.errors.length > 0) {
+        const errors = json.json.errors.map((e) => e.join(": ")).join(", ");
+        console.error(`[Reddit API] Reply errors: ${errors}`);
+        throw new Error(`Reddit API errors: ${errors}`);
+      } else {
+        console.error(`[Reddit API] Unexpected reply response format`);
+        throw new Error("Failed to parse reply response");
+      }
+    } catch (error) {
+      console.error(`[Reddit API] Reply to post exception:`, error);
+      if (error instanceof Error && error.message.includes("HTTP")) {
+        throw error;
+      }
+      throw new Error(`Failed to reply to post ${postId}: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
+  async deletePost(thingId) {
+    await this.authenticate();
+    if (!this.username || !this.password) {
+      throw new Error("User authentication required for deleting content");
+    }
+    try {
+      const fullThingId = thingId.startsWith("t3_") || thingId.startsWith("t1_") ? thingId : `t3_${thingId}`;
+      const params = new URLSearchParams();
+      params.append("id", fullThingId);
+      const response = await this.makeRequest("/api/del", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params.toString()
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`[Reddit API] Delete failed: ${response.status} ${response.statusText}`);
+        console.error(`[Reddit API] Error response: ${errorText}`);
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
+      }
+      console.error(`[Reddit API] Successfully deleted ${fullThingId}`);
+      return true;
+    } catch (error) {
+      console.error(`[Reddit API] Delete exception:`, error);
+      if (error instanceof Error && error.message.includes("HTTP")) {
+        throw error;
+      }
+      throw new Error(`Failed to delete content ${thingId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async deleteComment(thingId) {
+    const fullThingId = thingId.startsWith("t1_") ? thingId : `t1_${thingId}`;
+    return this.deletePost(fullThingId);
+  }
+  async editPost(thingId, newText) {
+    var _a;
+    await this.authenticate();
+    if (!this.username || !this.password) {
+      throw new Error("User authentication required for editing content");
+    }
+    try {
+      const fullThingId = thingId.startsWith("t3_") || thingId.startsWith("t1_") ? thingId : `t3_${thingId}`;
+      const params = new URLSearchParams();
+      params.append("thing_id", fullThingId);
+      params.append("text", newText);
+      params.append("api_type", "json");
+      const response = await this.makeRequest("/api/editusertext", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params.toString()
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`[Reddit API] Edit failed: ${response.status} ${response.statusText}`);
+        console.error(`[Reddit API] Error response: ${errorText}`);
+        throw new Error(`HTTP ${response.status}: ${errorText}`);
+      }
+      const json = await response.json();
+      console.error(`[Reddit API] Edit response:`, JSON.stringify(json, null, 2));
+      if (((_a = json.json) == null ? void 0 : _a.errors) && json.json.errors.length > 0) {
+        const errors = json.json.errors.map((e) => e.join(": ")).join(", ");
+        console.error(`[Reddit API] Edit errors: ${errors}`);
+        throw new Error(`Reddit API errors: ${errors}`);
+      }
+      console.error(`[Reddit API] Successfully edited ${fullThingId}`);
+      return true;
+    } catch (error) {
+      console.error(`[Reddit API] Edit exception:`, error);
+      if (error instanceof Error && error.message.includes("HTTP")) {
+        throw error;
+      }
+      throw new Error(`Failed to edit content ${thingId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async editComment(thingId, newText) {
+    const fullThingId = thingId.startsWith("t1_") ? thingId : `t1_${thingId}`;
+    return this.editPost(fullThingId, newText);
+  }
   async searchReddit(query, options = {}) {
     await this.authenticate();
     try {
@@ -664,21 +777,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");
@@ -759,62 +857,137 @@ 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
-  };
-}
 
-// src/tools/user-tools.ts
-var import_types = require("@modelcontextprotocol/sdk/types.js");
-async function getUserInfo(params) {
-  const { username } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
+// src/index.ts
+var import_dotenv = __toESM(require("dotenv"));
+import_dotenv.default.config();
+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 {
-    const user = await client.getUser(username);
+    const client = initializeRedditClient({
+      clientId,
+      clientSecret,
+      userAgent,
+      username,
+      password
+    });
+    console.error("[Setup] Reddit client initialized");
+    console.error("[Setup] Testing Reddit API connection...");
+    const isConnected = await client.checkAuthentication();
+    if (!isConnected) {
+      console.error("[Error] \u2717 Failed to connect to Reddit API");
+      console.error("[Error] Please check your REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET");
+      process.exit(1);
+    }
+    console.error("[Setup] \u2713 Reddit API connection successful");
+    if (username && password) {
+      console.error(`[Setup] \u2713 User authenticated as: ${username}`);
+      console.error("[Setup] Write operations enabled (posting, replying, editing, deleting)");
+    } else {
+      console.error("[Setup] Running in read-only mode (client credentials only)");
+      console.error("[Setup] For write operations, set REDDIT_USERNAME and REDDIT_PASSWORD");
+    }
+  } catch (error) {
+    console.error("[Error] \u2717 Reddit API connection failed:", error instanceof Error ? error.message : error);
+    console.error("[Error] Please verify your Reddit API credentials");
+    process.exit(1);
+  }
+}
+var 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)
+- Edit your own posts and comments (with authentication)
+- Delete your own posts and comments (with authentication)
+- Analyze engagement metrics and community insights
+
+For write operations (posting, replying, editing, deleting), 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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    const user = await client.getUser(args.username);
     const formattedUser = formatUserInfo(user);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# User Information: u/${formattedUser.username}
+    return `# User Information: u/${formattedUser.username}
 
 ## Profile Overview
 - Username: u/${formattedUser.username}
@@ -830,113 +1003,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)}`);
+- ${formattedUser.recommendations.replace(/\n {2}- /g, "\n- ")}`;
   }
-}
-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
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    const posts = await client.getUserPosts(args.username, {
+      sort: args.sort,
+      timeFilter: args.time_filter,
+      limit: args.limit
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Posts by u/${username}
-
-## Sort: ${sort} | Time: ${time_filter} | Count: ${posts.length}
-
-${posts.map((post, index) => {
-            const date = new Date(post.createdUtc * 1e3).toLocaleString();
-            const selftext = post.selftext ? `
-${post.selftext.substring(0, 200)}${post.selftext.length > 200 ? "..." : ""}
-` : "";
-            return `### ${index + 1}. ${post.title}
+    if (posts.length === 0) {
+      return `No posts found for u/${args.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} (${Math.round(post.upvoteRatio * 100)}% upvoted)
-- Comments: ${post.numComments}
-- Posted: ${date}
-${selftext}
-- Link: https://reddit.com${post.permalink}
-${post.over18 ? "- **NSFW**" : ""}
-${post.spoiler ? "- **Spoiler**" : ""}`;
-          }).join("\n\n---\n\n")}`
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user posts: ${String(error)}`);
-  }
-}
-async function getUserComments(params) {
-  const { username, sort = "new", time_filter = "all", limit = 10 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, "Reddit client not initialized");
+- 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/${args.username} (${args.sort} - ${args.time_filter})
+
+${postSummaries}`;
   }
-  try {
-    const comments = await client.getUserComments(username, {
-      sort,
-      timeFilter: time_filter,
-      limit
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    const comments = await client.getUserComments(args.username, {
+      sort: args.sort,
+      timeFilter: args.time_filter,
+      limit: args.limit
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Comments by u/${username}
+    if (comments.length === 0) {
+      return `No comments found for u/${args.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/${args.username} (${args.sort} - ${args.time_filter})
 
-${body}`;
-          }).join("\n\n---\n\n")}`
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types.McpError(import_types.ErrorCode.InternalError, `Failed to fetch user comments: ${String(error)}`);
-  }
-}
-
-// src/tools/post-tools.ts
-var import_types2 = require("@modelcontextprotocol/sdk/types.js");
-async function getRedditPost(params) {
-  const { subreddit, post_id } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
+${commentSummaries}`;
   }
-  try {
-    const post = await client.getPost(post_id, subreddit);
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    const post = await client.getPost(args.post_id, args.subreddit);
     const formattedPost = formatPostInfo(post);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Post from r/${formattedPost.subreddit}
+    return `# Post from r/${formattedPost.subreddit}
 
 ## Post Details
 - Title: ${formattedPost.title}
@@ -964,130 +1123,56 @@ ${formattedPost.content}
 - ${formattedPost.engagementAnalysis.replace(/\n  - /g, "\n- ")}
 
 ## Best Time to Engage
-${formattedPost.bestTimeToEngage}
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to fetch post data: ${String(error)}`);
-  }
-}
-async function getTopPosts(params) {
-  const { subreddit, time_filter = "week", limit = 10 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
+${formattedPost.bestTimeToEngage}`;
   }
-  try {
-    const posts = await client.getTopPosts(subreddit, time_filter, limit);
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    const posts = await client.getTopPosts(args.subreddit || "", args.time_filter, args.limit);
+    if (posts.length === 0) {
+      const location2 = args.subreddit ? `r/${args.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}
+      (post, index) => `### ${index + 1}. ${post.title}
 - Author: u/${post.author}
 - Score: ${post.stats.score.toLocaleString()} (${(post.stats.upvoteRatio * 100).toFixed(1)}% upvoted)
 - Comments: ${post.stats.comments.toLocaleString()}
 - Posted: ${post.metadata.posted}
-- Link: ${post.links.shortLink}
-    `
-    ).join("\n");
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Top Posts from r/${subreddit} (${time_filter})
-
-${postSummaries}
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to fetch top posts: ${String(error)}`);
-  }
-}
-async function createPost(params) {
-  const { subreddit, title, content, is_self = true } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const post = await client.createPost(subreddit, title, content, is_self);
-    const formattedPost = formatPostInfo(post);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Post Created Successfully
-
-## Post Details
-- Title: ${formattedPost.title}
-- Subreddit: r/${formattedPost.subreddit}
-- Type: ${formattedPost.type}
-- Link: ${formattedPost.links.fullPost}
+- Link: ${post.links.shortLink}`
+    ).join("\n\n");
+    const location = args.subreddit ? `r/${args.subreddit}` : "Home Feed";
+    return `# Top Posts from ${location} (${args.time_filter})
 
-Your post has been successfully submitted to r/${formattedPost.subreddit}.
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to create post: ${String(error)}`);
+${postSummaries}`;
   }
-}
-async function replyToPost(params) {
-  const { post_id, content } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const comment = await client.replyToPost(post_id, content);
-    const formattedComment = formatCommentInfo(comment);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Reply Posted Successfully
-
-## Comment Details
-- Author: u/${formattedComment.author}
-- Subreddit: r/${formattedComment.context.subreddit}
-- Thread: ${formattedComment.context.thread}
-- Link: ${formattedComment.link}
-
-Your reply has been successfully posted.
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types2.McpError(import_types2.ErrorCode.InternalError, `Failed to reply to post: ${String(error)}`);
-  }
-}
-
-// src/tools/subreddit-tools.ts
-var import_types3 = require("@modelcontextprotocol/sdk/types.js");
-async function getSubredditInfo(params) {
-  const { subreddit_name } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
-    const subreddit = await client.getSubredditInfo(subreddit_name);
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    const subreddit = await client.getSubredditInfo(args.subreddit_name);
     const formattedSubreddit = formatSubredditInfo(subreddit);
-    return {
-      content: [
-        {
-          type: "text",
-          text: `
-# Subreddit Information: r/${formattedSubreddit.name}
+    return `# Subreddit Information: r/${formattedSubreddit.name}
 
 ## Overview
 - Name: r/${formattedSubreddit.name}
@@ -1113,582 +1198,327 @@ ${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)}`);
+- ${formattedSubreddit.engagementTips.replace(/\n  - /g, "\n- ")}`;
   }
-}
-async function getTrendingSubreddits() {
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  try {
+});
+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 {
-      content: [
-        {
-          type: "text",
-          text: `
-# Trending Subreddits
+    return `# Trending Subreddits
 
-${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}
-          `
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types3.McpError(import_types3.ErrorCode.InternalError, `Failed to fetch trending subreddits: ${String(error)}`);
+${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}`;
   }
-}
-
-// src/tools/search-tools.ts
-var import_types4 = require("@modelcontextprotocol/sdk/types.js");
-async function searchReddit(params) {
-  const { query, subreddit, sort = "relevance", time_filter = "all", limit = 10, type = "link" } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types4.McpError(import_types4.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  if (!query || query.trim().length === 0) {
-    throw new import_types4.McpError(import_types4.ErrorCode.InvalidParams, "Search query cannot be empty");
-  }
-  try {
-    const posts = await client.searchReddit(query, {
-      subreddit,
-      sort,
-      timeFilter: time_filter,
-      limit,
-      type
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!args.query || args.query.trim() === "") {
+      throw new Error("Search query cannot be empty");
+    }
+    const posts = await client.searchReddit(args.query, {
+      subreddit: args.subreddit,
+      sort: args.sort,
+      timeFilter: args.time_filter,
+      limit: args.limit,
+      type: args.type
     });
-    return {
-      content: [
-        {
-          type: "text",
-          text: `# Reddit Search Results for: "${query}"${subreddit ? ` in r/${subreddit}` : ""}
-
-## Search Parameters
-- Sort: ${sort}
-- Time Filter: ${time_filter}
-- Type: ${type}
-- Results: ${posts.length}
+    if (posts.length === 0) {
+      const searchLocation2 = args.subreddit ? ` in r/${args.subreddit}` : "";
+      return `No results found for "${args.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 = args.subreddit ? ` in r/${args.subreddit}` : "";
+    return `# Reddit Search Results for: "${args.query}"${searchLocation}
 
-${posts.map((post, index) => {
-            const formatted = formatPost(post);
-            return `### ${index + 1}. ${formatted.title}
-- Author: u/${formatted.author}
-- Subreddit: r/${formatted.subreddit}
-- Score: ${formatted.score} (${formatted.upvoteRatio}% upvoted)
-- Comments: ${formatted.numComments}
-- Posted: ${formatted.createdAt}
-${formatted.selftext ? `
-${formatted.selftext.substring(0, 200)}${formatted.selftext.length > 200 ? "..." : ""}
-` : ""}
-- Link: https://reddit.com${formatted.permalink}
-${formatted.nsfw ? "- **NSFW**" : ""}
-${formatted.spoiler ? "- **Spoiler**" : ""}
-`;
-          }).join("\n")}`
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types4.McpError(import_types4.ErrorCode.InternalError, `Failed to search Reddit: ${String(error)}`);
-  }
-}
+Sorted by: ${args.sort} | Time: ${args.time_filter} | Type: ${args.type}
 
-// src/tools/comment-tools.ts
-var import_types5 = require("@modelcontextprotocol/sdk/types.js");
-async function getPostComments(params) {
-  const { post_id, subreddit, sort = "best", limit = 100 } = params;
-  const client = getRedditClient();
-  if (!client) {
-    throw new import_types5.McpError(import_types5.ErrorCode.InternalError, "Reddit client not initialized");
-  }
-  if (!post_id || !subreddit) {
-    throw new import_types5.McpError(import_types5.ErrorCode.InvalidParams, "post_id and subreddit are required");
+${searchResults}`;
   }
-  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}
+});
+server.addTool({
+  name: "create_post",
+  description: "Create a new post in a subreddit (requires REDDIT_USERNAME and REDDIT_PASSWORD)",
+  parameters: import_zod.z.object({
+    subreddit: import_zod.z.string().describe("The subreddit name (without r/ prefix)"),
+    title: import_zod.z.string().describe("The post title"),
+    content: import_zod.z.string().describe("The post content (text for self posts, URL for link posts)"),
+    is_self: import_zod.z.boolean().default(true).describe("Whether this is a self post (text) or link post")
+  }),
+  execute: async (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!process.env.REDDIT_USERNAME || !process.env.REDDIT_PASSWORD) {
+      throw new Error(
+        "User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD environment variables."
+      );
+    }
+    const post = await client.createPost(args.subreddit, args.title, args.content, args.is_self);
+    const formattedPost = formatPostInfo(post);
+    return `# Post Created Successfully
 
 ## Post Details
-- Author: u/${formattedPost.author}
+- Title: ${formattedPost.title}
 - Subreddit: r/${formattedPost.subreddit}
-- Score: ${formattedPost.score} (${formattedPost.upvoteRatio}% upvoted)
-- Posted: ${formattedPost.createdAt}
-- Link: https://reddit.com${formattedPost.permalink}
+- Type: ${formattedPost.type}
+- Link: ${formattedPost.links.fullPost}
 
-## Post Content
-${formattedPost.selftext || "[Link post - no text content]"}
+Your post has been successfully submitted to r/${formattedPost.subreddit}.`;
+  }
+});
+server.addTool({
+  name: "reply_to_post",
+  description: "Post a reply to an existing Reddit post or comment (requires REDDIT_USERNAME and REDDIT_PASSWORD)",
+  parameters: import_zod.z.object({
+    post_id: import_zod.z.string().describe("The Reddit post ID (thing_id, e.g., t3_xxxxx for posts, t1_xxxxx for comments)"),
+    content: import_zod.z.string().describe("The reply content")
+  }),
+  execute: async (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!process.env.REDDIT_USERNAME || !process.env.REDDIT_PASSWORD) {
+      throw new Error(
+        "User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD environment variables."
+      );
+    }
+    const comment = await client.replyToPost(args.post_id, args.content);
+    return `# Reply Posted Successfully
 
-## Comments (${comments.length} loaded, sorted by ${sort})
+## Comment Details
+- Posted to: ${args.post_id}
+- Author: u/${process.env.REDDIT_USERNAME}
+- Comment ID: ${comment.id}
 
-${comments.map((comment) => formatComment(comment)).join("\n\n---\n\n")}`
-        }
-      ]
-    };
-  } catch (error) {
-    throw new import_types5.McpError(import_types5.ErrorCode.InternalError, `Failed to fetch comments: ${String(error)}`);
+Your reply has been successfully posted.`;
   }
-}
+});
+server.addTool({
+  name: "delete_post",
+  description: "Delete your own Reddit post (requires REDDIT_USERNAME and REDDIT_PASSWORD). WARNING: This action is permanent and cannot be undone!",
+  parameters: import_zod.z.object({
+    thing_id: import_zod.z.string().describe(
+      "The full Reddit thing ID (e.g., 't3_abc123' for posts) or just the post ID (e.g., 'abc123'). The 't3_' prefix will be added automatically if missing."
+    )
+  }),
+  execute: async (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!process.env.REDDIT_USERNAME || !process.env.REDDIT_PASSWORD) {
+      throw new Error(
+        "User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD environment variables."
+      );
+    }
+    await client.deletePost(args.thing_id);
+    return `# Post Deleted Successfully
 
-// src/index.ts
-var import_dotenv = __toESM(require("dotenv"));
-import_dotenv.default.config();
-var RedditServer = class {
-  server;
-  constructor() {
-    this.server = new import_server.Server(
-      {
-        name: "reddit-mcp-server",
-        version: "0.1.0"
-      },
-      {
-        capabilities: {
-          tools: {},
-          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);
-    });
+The post ${args.thing_id} has been permanently deleted from Reddit.
+
+**Note**: This action cannot be undone. The post content has been removed and cannot be recovered.`;
   }
-  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."
+});
+server.addTool({
+  name: "delete_comment",
+  description: "Delete your own Reddit comment (requires REDDIT_USERNAME and REDDIT_PASSWORD). WARNING: This action is permanent and cannot be undone!",
+  parameters: import_zod.z.object({
+    thing_id: import_zod.z.string().describe(
+      "The full Reddit thing ID (e.g., 't1_abc123' for comments) or just the comment ID (e.g., 'abc123'). The 't1_' prefix will be added automatically if missing."
+    )
+  }),
+  execute: async (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!process.env.REDDIT_USERNAME || !process.env.REDDIT_PASSWORD) {
+      throw new Error(
+        "User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD 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);
+    await client.deleteComment(args.thing_id);
+    return `# Comment Deleted Successfully
+
+The comment ${args.thing_id} has been permanently deleted from Reddit.
+
+**Note**: This action cannot be undone. The comment content has been removed and cannot be recovered.`;
+  }
+});
+server.addTool({
+  name: "edit_post",
+  description: "Edit your own Reddit post (self-text posts only, requires REDDIT_USERNAME and REDDIT_PASSWORD). You can only edit the text content of self posts, not titles or link posts.",
+  parameters: import_zod.z.object({
+    thing_id: import_zod.z.string().describe(
+      "The full Reddit thing ID (e.g., 't3_abc123' for posts) or just the post ID (e.g., 'abc123'). The 't3_' prefix will be added automatically if missing."
+    ),
+    new_text: import_zod.z.string().describe("The new text content for the post. Supports Reddit markdown formatting.")
+  }),
+  execute: async (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!process.env.REDDIT_USERNAME || !process.env.REDDIT_PASSWORD) {
+      throw new Error(
+        "User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD environment variables."
+      );
     }
+    await client.editPost(args.thing_id, args.new_text);
+    return `# Post Edited Successfully
+
+The post ${args.thing_id} has been updated with your new content.
+
+**Note**:
+- Only self (text) posts can be edited
+- Post titles cannot be edited
+- Link posts cannot be edited
+- An "edited" marker will appear on your post`;
   }
-  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;
-      }
-    });
+});
+server.addTool({
+  name: "edit_comment",
+  description: "Edit your own Reddit comment (requires REDDIT_USERNAME and REDDIT_PASSWORD). Update the text content of a comment you previously posted.",
+  parameters: import_zod.z.object({
+    thing_id: import_zod.z.string().describe(
+      "The full Reddit thing ID (e.g., 't1_abc123' for comments) or just the comment ID (e.g., 'abc123'). The 't1_' prefix will be added automatically if missing."
+    ),
+    new_text: import_zod.z.string().describe("The new text content for the comment. Supports Reddit markdown formatting.")
+  }),
+  execute: async (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!process.env.REDDIT_USERNAME || !process.env.REDDIT_PASSWORD) {
+      throw new Error(
+        "User authentication required. Please set REDDIT_USERNAME and REDDIT_PASSWORD environment variables."
+      );
+    }
+    await client.editComment(args.thing_id, args.new_text);
+    return `# Comment Edited Successfully
+
+The comment ${args.thing_id} has been updated with your new content.
+
+**Note**: An "edited" marker will appear on your comment to show it has been modified.`;
   }
-  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)"
+});
+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 (args) => {
+    const client = getRedditClient();
+    if (!client) {
+      throw new Error("Reddit client not initialized");
+    }
+    if (!args.post_id || !args.subreddit) {
+      throw new Error("post_id and subreddit are required");
+    }
+    const data = await client.getPostComments(args.post_id, args.subreddit, {
+      sort: args.sort,
+      limit: args.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;
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RedditServer
 });
+async function main() {
+  try {
+    await setupRedditClient();
+    const useStdio = process.env.TRANSPORT_TYPE === "stdio";
+    const port = parseInt(process.env.PORT || "3000");
+    const host = process.env.HOST || "0.0.0.0";
+    if (useStdio) {
+      console.error("[Setup] Starting in stdio mode (CLI/npx)");
+      await server.start({
+        transportType: "stdio"
+      });
+    } else {
+      console.error(`[Setup] Starting HTTP server on ${host}:${port}`);
+      await server.start({
+        transportType: "httpStream",
+        httpStream: {
+          port,
+          host,
+          endpoint: "/mcp"
+        }
+      });
+      console.error(`[Setup] HTTP server ready at http://${host}:${port}/mcp`);
+      console.error(`[Setup] SSE endpoint available at http://${host}:${port}/sse`);
+    }
+  } catch (error) {
+    console.error("[Error] Failed to start server:", error);
+    process.exit(1);
+  }
+}
+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);