reddit-mcp-server 1.0.4 → 1.0.6

package/src/index.ts

@@ -52,10 +52,7 @@ class RedditServer {
 
     if (!clientId || !clientSecret) {
       // Can't use server logging here as server isn't initialized yet
-      // Using console.error is OK for startup failures
-      console.error(
-        "[Error] Missing required Reddit API credentials. Please set REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET environment variables.",
-      )
+      // Exit silently with error code
       process.exit(1)
     }
 
@@ -69,9 +66,9 @@ class RedditServer {
       })
 
       // Client initialized successfully
-    } catch (error) {
+    } catch {
       // Can't use server logging here as server isn't connected yet
-      console.error("[Error] Failed to initialize Reddit client:", error)
+      // Exit silently with error code
       process.exit(1)
     }
   }
@@ -217,6 +214,146 @@ class RedditServer {
             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"],
+          },
+        },
       ],
     }))
 
@@ -283,6 +420,48 @@ class RedditServer {
               },
             )
 
+          case "search_reddit":
+            return await tools.searchReddit(
+              toolParams as {
+                query: string
+                subreddit?: string
+                sort?: string
+                time_filter?: string
+                limit?: number
+                type?: string
+              },
+            )
+
+          case "get_post_comments":
+            return await tools.getPostComments(
+              toolParams as {
+                post_id: string
+                subreddit: string
+                sort?: string
+                limit?: number
+              },
+            )
+
+          case "get_user_posts":
+            return await tools.getUserPosts(
+              toolParams as {
+                username: string
+                sort?: string
+                time_filter?: string
+                limit?: number
+              },
+            )
+
+          case "get_user_comments":
+            return await tools.getUserComments(
+              toolParams as {
+                username: string
+                sort?: string
+                time_filter?: string
+                limit?: number
+              },
+            )
+
           default:
             throw new McpError(ErrorCode.MethodNotFound, `Tool with name ${toolName} not found`)
         }
@@ -330,7 +509,10 @@ class RedditServer {
 // Only run if this is the main module
 if (require.main === module) {
   const server = new RedditServer()
-  server.run().catch(console.error)
+  server.run().catch(() => {
+    // Exit silently on error
+    process.exit(1)
+  })
 }
 
 export { RedditServer }

package/src/tools/__tests__/comment-tools.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { getPostComments } from "../comment-tools"
+import { getRedditClient } from "../../client/reddit-client"
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
+
+vi.mock("../../client/reddit-client")
+
+describe("getPostComments", () => {
+  const mockRedditClient = {
+    getPostComments: vi.fn(),
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(getRedditClient).mockReturnValue(mockRedditClient as any)
+  })
+
+  it("should fetch post comments with default parameters", async () => {
+    const mockData = {
+      post: {
+        id: "test123",
+        title: "Test Post Title",
+        author: "testauthor",
+        subreddit: "testsubreddit",
+        score: 500,
+        upvoteRatio: 0.9,
+        numComments: 25,
+        createdUtc: 1700000000,
+        selftext: "This is the post content",
+        permalink: "/r/testsubreddit/comments/test123",
+        over18: false,
+        spoiler: false,
+      },
+      comments: [
+        {
+          id: "comment1",
+          author: "commenter1",
+          body: "This is a comment",
+          score: 10,
+          createdUtc: 1700000100,
+          edited: false,
+          isSubmitter: false,
+          depth: 0,
+        },
+        {
+          id: "comment2",
+          author: "testauthor",
+          body: "This is a reply from OP",
+          score: 5,
+          createdUtc: 1700000200,
+          edited: true,
+          isSubmitter: true,
+          depth: 1,
+        },
+      ],
+    }
+
+    mockRedditClient.getPostComments.mockResolvedValue(mockData)
+
+    const result = await getPostComments({
+      post_id: "test123",
+      subreddit: "testsubreddit",
+    })
+
+    expect(mockRedditClient.getPostComments).toHaveBeenCalledWith("test123", "testsubreddit", {
+      sort: "best",
+      limit: 100,
+    })
+
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("text")
+    expect(result.content[0].text).toContain("Comments for: Test Post Title")
+    expect(result.content[0].text).toContain("**u/commenter1**")
+    expect(result.content[0].text).toContain("**u/testauthor** **[OP]**")
+    expect(result.content[0].text).toContain("└─")
+  })
+
+  it("should fetch comments with custom parameters", async () => {
+    mockRedditClient.getPostComments.mockResolvedValue({ post: {}, comments: [] })
+
+    await getPostComments({
+      post_id: "test456",
+      subreddit: "programming",
+      sort: "controversial",
+      limit: 50,
+    })
+
+    expect(mockRedditClient.getPostComments).toHaveBeenCalledWith("test456", "programming", {
+      sort: "controversial",
+      limit: 50,
+    })
+  })
+
+  it("should throw error if Reddit client is not initialized", async () => {
+    vi.mocked(getRedditClient).mockReturnValue(null)
+
+    await expect(getPostComments({ post_id: "test", subreddit: "test" })).rejects.toThrow(
+      new McpError(ErrorCode.InternalError, "Reddit client not initialized"),
+    )
+  })
+
+  it("should throw error if required parameters are missing", async () => {
+    await expect(getPostComments({ post_id: "", subreddit: "test" })).rejects.toThrow(
+      new McpError(ErrorCode.InvalidParams, "post_id and subreddit are required"),
+    )
+
+    await expect(getPostComments({ post_id: "test", subreddit: "" })).rejects.toThrow(
+      new McpError(ErrorCode.InvalidParams, "post_id and subreddit are required"),
+    )
+  })
+
+  it("should handle API errors", async () => {
+    mockRedditClient.getPostComments.mockRejectedValue(new Error("API Error"))
+
+    await expect(getPostComments({ post_id: "test", subreddit: "test" })).rejects.toThrow(
+      new McpError(ErrorCode.InternalError, "Failed to fetch comments: Error: API Error"),
+    )
+  })
+})

package/src/tools/__tests__/search-tools.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, vi, beforeEach } from "vitest"
+import { searchReddit } from "../search-tools"
+import { getRedditClient } from "../../client/reddit-client"
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js"
+
+vi.mock("../../client/reddit-client")
+
+describe("searchReddit", () => {
+  const mockRedditClient = {
+    searchReddit: vi.fn(),
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.mocked(getRedditClient).mockReturnValue(mockRedditClient as any)
+  })
+
+  it("should search Reddit with default parameters", async () => {
+    const mockPosts = [
+      {
+        id: "test1",
+        title: "Test Post 1",
+        author: "testuser1",
+        subreddit: "testsubreddit",
+        score: 100,
+        upvoteRatio: 0.95,
+        numComments: 10,
+        createdUtc: 1700000000,
+        selftext: "This is a test post",
+        permalink: "/r/testsubreddit/comments/test1",
+        over18: false,
+        spoiler: false,
+      },
+    ]
+
+    mockRedditClient.searchReddit.mockResolvedValue(mockPosts)
+
+    const result = await searchReddit({ query: "test query" })
+
+    expect(mockRedditClient.searchReddit).toHaveBeenCalledWith("test query", {
+      subreddit: undefined,
+      sort: "relevance",
+      timeFilter: "all",
+      limit: 10,
+      type: "link",
+    })
+
+    expect(result.content).toHaveLength(1)
+    expect(result.content[0].type).toBe("text")
+    expect(result.content[0].text).toContain('Reddit Search Results for: "test query"')
+    expect(result.content[0].text).toContain("Test Post 1")
+  })
+
+  it("should search within a specific subreddit", async () => {
+    mockRedditClient.searchReddit.mockResolvedValue([])
+
+    await searchReddit({
+      query: "test",
+      subreddit: "programming",
+      sort: "top",
+      time_filter: "week",
+      limit: 5,
+      type: "link",
+    })
+
+    expect(mockRedditClient.searchReddit).toHaveBeenCalledWith("test", {
+      subreddit: "programming",
+      sort: "top",
+      timeFilter: "week",
+      limit: 5,
+      type: "link",
+    })
+  })
+
+  it("should throw error if Reddit client is not initialized", async () => {
+    vi.mocked(getRedditClient).mockReturnValue(null)
+
+    await expect(searchReddit({ query: "test" })).rejects.toThrow(
+      new McpError(ErrorCode.InternalError, "Reddit client not initialized"),
+    )
+  })
+
+  it("should throw error if query is empty", async () => {
+    await expect(searchReddit({ query: "" })).rejects.toThrow(
+      new McpError(ErrorCode.InvalidParams, "Search query cannot be empty"),
+    )
+
+    await expect(searchReddit({ query: "   " })).rejects.toThrow(
+      new McpError(ErrorCode.InvalidParams, "Search query cannot be empty"),
+    )
+  })
+
+  it("should handle search errors", async () => {
+    mockRedditClient.searchReddit.mockRejectedValue(new Error("API Error"))
+
+    await expect(searchReddit({ query: "test" })).rejects.toThrow(
+      new McpError(ErrorCode.InternalError, "Failed to search Reddit: Error: API Error"),
+    )
+  })
+})