reddit-mcp-server 1.1.1 → 1.1.2

package/README.md

@@ -2,7 +2,7 @@
 
 A Model Context Protocol (MCP) that provides tools for fetching and creating Reddit content.
 
-> **Note**: This is a fork of the original [reddit-mcp-server](https://github.com/alexandros-lekkas/reddit-mcp-server) by Alexandros Lekkas, updated with pnpm, tsup build system, and npx execution support.
+> **Note**: This is a fork of the [reddit-mcp-server](https://github.com/alexandros-lekkas/reddit-mcp-server) by Alexandros Lekkas, updated with pnpm, tsup build system, and npx execution support.
 
 ## 🔧 Available Tools (Features)
 
@@ -22,6 +22,10 @@ A Model Context Protocol (MCP) that provides tools for fetching and creating Red
 
 - `create_post(subreddit, title, content, is_self)` - Create a new post in a subreddit
 - `reply_to_post(post_id, content, subreddit?)` - Post a reply to an existing Reddit post
+- `edit_post(thing_id, new_text)` - Edit your own Reddit post (self-text posts only)
+- `edit_comment(thing_id, new_text)` - Edit your own Reddit comment
+- `delete_post(thing_id)` - Delete your own Reddit post
+- `delete_comment(thing_id)` - Delete your own Reddit comment
 
 ## 🔌 Installation
 
@@ -85,8 +89,12 @@ If you want to write posts you need to include your `REDDIT_USERNAME` and `REDDI
         "get_user_posts",
         "get_user_comments",
         "create_post",
-        "reply_to_post"
-      ] // You don't need to add this, but it makes it so that you don't have to keep clicking approve
+        "reply_to_post",
+        "edit_post",
+        "edit_comment",
+        "delete_post",
+        "delete_comment"
+      ] // Optional if you do not want to always approve
     }
   }
 ```
@@ -131,19 +139,19 @@ npx reddit-mcp-server --help
 npx reddit-mcp-server --generate-token
 ```
 
-### Streamable MCP Endpoint (Hono Server)
+### HTTP MCP Endpoint (FastMCP)
 
-In addition to the standard npx execution, this server also supports a Streamable MCP endpoint via Hono for direct HTTP integration:
+In addition to the standard npx execution, this server supports HTTP transport via FastMCP for direct HTTP integration:
 
 ```bash
-# Start the Hono server on port 3000 (default)
-pnpm serve
+# Start the HTTP server on port 3000 (default)
+node dist/index.js
 
 # Start with custom port
-PORT=8080 pnpm serve
+PORT=8080 node dist/index.js
 
-# Development mode with auto-reload
-pnpm serve:dev
+# Or use the npm script
+pnpm start
 ```
 
 The server will be available at `http://localhost:3000` with the MCP endpoint at `http://localhost:3000/mcp`.
@@ -380,7 +388,7 @@ OAuth is not applicable when using the traditional npx execution method. Use the
    await client.connect(transport);
    ```
 
-This allows integration with systems that support HTTP-based MCP communication, similar to the cq-api and agent-todo implementations.
+This allows integration with systems that support HTTP-based MCP communication via the FastMCP framework.
 
 ## 🐳 Docker Usage
 

package/dist/bin.js

@@ -26,9 +26,9 @@ 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.5_typescript@5.9.2/node_modules/tsup/assets/cjs_shims.js
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "node_modules/.pnpm/tsup@8.5.0_postcss@8.5.6_tsx@4.20.5_typescript@5.9.2/node_modules/tsup/assets/cjs_shims.js"() {
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
@@ -98,7 +98,8 @@ var init_reddit_client = __esm({
           }
           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);
@@ -116,13 +117,17 @@ var init_reddit_client = __esm({
             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");
         }
       }
@@ -280,6 +285,7 @@ var init_reddit_client = __esm({
         }
       }
       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");
@@ -291,6 +297,7 @@ var init_reddit_client = __esm({
           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: {
@@ -299,17 +306,33 @@ var init_reddit_client = __esm({
             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) {
@@ -337,6 +360,7 @@ var init_reddit_client = __esm({
           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: {
@@ -345,26 +369,126 @@ var init_reddit_client = __esm({
             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 {
@@ -769,7 +893,7 @@ async function setupRedditClient() {
     process.exit(1);
   }
   try {
-    initializeRedditClient({
+    const client = initializeRedditClient({
       clientId,
       clientSecret,
       userAgent,
@@ -777,22 +901,51 @@ async function setupRedditClient() {
       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] Authenticated as user: ${username}`);
+      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 (no user authentication)");
+      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] Failed to initialize Reddit client:", 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);
   }
 }
 async function main() {
   try {
     await setupRedditClient();
-    await server.start({
-      transportType: "stdio"
-    });
+    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);
@@ -813,15 +966,17 @@ var init_src = __esm({
       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  
+- 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), ensure REDDIT_USERNAME and REDDIT_PASSWORD are configured.`,
+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) => {
@@ -1168,6 +1323,176 @@ Sorted by: ${args2.sort} | Time: ${args2.time_filter} | Type: ${args2.type}
 ${searchResults}`;
       }
     });
+    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 (args2) => {
+        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(args2.subreddit, args2.title, args2.content, args2.is_self);
+        const formattedPost = formatPostInfo(post);
+        return `# 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}.`;
+      }
+    });
+    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 (args2) => {
+        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(args2.post_id, args2.content);
+        return `# Reply Posted Successfully
+
+## Comment Details
+- Posted to: ${args2.post_id}
+- Author: u/${process.env.REDDIT_USERNAME}
+- Comment ID: ${comment.id}
+
+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 (args2) => {
+        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(args2.thing_id);
+        return `# Post Deleted Successfully
+
+The post ${args2.thing_id} has been permanently deleted from Reddit.
+
+**Note**: This action cannot be undone. The post content has been removed and cannot be recovered.`;
+      }
+    });
+    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 (args2) => {
+        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.deleteComment(args2.thing_id);
+        return `# Comment Deleted Successfully
+
+The comment ${args2.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 (args2) => {
+        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(args2.thing_id, args2.new_text);
+        return `# Post Edited Successfully
+
+The post ${args2.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`;
+      }
+    });
+    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 (args2) => {
+        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(args2.thing_id, args2.new_text);
+        return `# Comment Edited Successfully
+
+The comment ${args2.thing_id} has been updated with your new content.
+
+**Note**: An "edited" marker will appear on your comment to show it has been modified.`;
+      }
+    });
     server.addTool({
       name: "get_post_comments",
       description: "Get comments from a specific Reddit post",
@@ -1236,6 +1561,9 @@ var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var packageJsonPath = import_path.default.join(__dirname, "..", "package.json");
 var packageJson = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+if (!process.env.TRANSPORT_TYPE) {
+  process.env.TRANSPORT_TYPE = "stdio";
+}
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   console.log(packageJson.version);

package/dist/index.js

@@ -79,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);
@@ -97,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");
     }
   }
@@ -261,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");
@@ -272,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: {
@@ -280,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) {
@@ -318,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: {
@@ -326,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 {
@@ -750,7 +874,7 @@ async function setupRedditClient() {
     process.exit(1);
   }
   try {
-    initializeRedditClient({
+    const client = initializeRedditClient({
       clientId,
       clientSecret,
       userAgent,
@@ -758,13 +882,24 @@ async function setupRedditClient() {
       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] Authenticated as user: ${username}`);
+      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 (no user authentication)");
+      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] Failed to initialize Reddit client:", 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);
   }
 }
@@ -772,15 +907,17 @@ 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  
+- 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), ensure REDDIT_USERNAME and REDDIT_PASSWORD are configured.`,
+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) => {
@@ -1127,6 +1264,176 @@ Sorted by: ${args.sort} | Time: ${args.time_filter} | Type: ${args.type}
 ${searchResults}`;
   }
 });
+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
+- Title: ${formattedPost.title}
+- Subreddit: r/${formattedPost.subreddit}
+- Type: ${formattedPost.type}
+- Link: ${formattedPost.links.fullPost}
+
+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
+
+## Comment Details
+- Posted to: ${args.post_id}
+- Author: u/${process.env.REDDIT_USERNAME}
+- Comment ID: ${comment.id}
+
+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
+
+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.`;
+  }
+});
+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."
+      );
+    }
+    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`;
+  }
+});
+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.`;
+  }
+});
 server.addTool({
   name: "get_post_comments",
   description: "Get comments from a specific Reddit post",
@@ -1180,9 +1487,27 @@ ${comment.body}
 async function main() {
   try {
     await setupRedditClient();
-    await server.start({
-      transportType: "stdio"
-    });
+    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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reddit-mcp-server",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "A Model Context Protocol (MCP) that provides tools for fetching and creating Reddit content. Fork of the alexandros-lekkas/reddit-mcp-server.",
   "main": "dist/index.js",
   "exports": {
@@ -21,6 +21,7 @@
     "api",
     "model-context-protocol"
   ],
+  "mcpName": "io.github.jordanburke.reddit-mcp-server",
   "author": "Jordan Burke <jordan.burke@gmail.com>",
   "license": "MIT",
   "repository": {
@@ -33,25 +34,26 @@
   "homepage": "https://github.com/jordanburke/reddit-mcp-server#readme",
   "dependencies": {
     "dotenv": "^16.6.1",
-    "fastmcp": "^3.18.0",
-    "zod": "^4.1.11"
+    "fastmcp": "^3.24.0",
+    "zod": "^4.1.13"
   },
   "devDependencies": {
-    "@eslint/js": "^9.36.0",
-    "@types/node": "^22.18.6",
-    "@typescript-eslint/eslint-plugin": "^8.44.1",
-    "@typescript-eslint/parser": "^8.44.1",
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^22.19.1",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
     "@vitest/coverage-v8": "^3.2.4",
-    "cross-env": "^10.0.0",
-    "eslint": "^9.36.0",
+    "ajv-cli": "^5.0.0",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.4",
-    "msw": "^2.11.3",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "tsup": "^8.5.0",
-    "tsx": "^4.20.5",
-    "typescript": "^5.9.2",
+    "msw": "^2.12.4",
+    "prettier": "^3.7.4",
+    "rimraf": "^6.1.2",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
   "scripts": {