reddit-mcp-server 1.1.1 → 1.2.0

package/dist/index.js

@@ -1,856 +1,984 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/index.ts
-var import_fastmcp = require("fastmcp");
-var import_zod = require("zod");
+const require_chunk = require('./chunk-kSYXY2_d.js');
+let fastmcp = require("fastmcp");
+let zod = require("zod");
+let crypto = require("crypto");
+crypto = require_chunk.__toESM(crypto);
+let dotenv = require("dotenv");
+dotenv = require_chunk.__toESM(dotenv);
 
-// src/client/reddit-client.ts
+//#region src/client/reddit-client.ts
 var RedditClient = class {
-  clientId;
-  clientSecret;
-  userAgent;
-  username;
-  password;
-  accessToken;
-  tokenExpiry = 0;
-  baseUrl = "https://oauth.reddit.com";
-  authenticated = false;
-  constructor(config) {
-    this.clientId = config.clientId;
-    this.clientSecret = config.clientSecret;
-    this.userAgent = config.userAgent;
-    this.username = config.username;
-    this.password = config.password;
-  }
-  async makeRequest(path, options = {}) {
-    if (Date.now() >= this.tokenExpiry || !this.authenticated) {
-      await this.authenticate();
-    }
-    const url = `${this.baseUrl}${path}`;
-    const headers = {
-      "User-Agent": this.userAgent,
-      Authorization: `Bearer ${this.accessToken}`,
-      ...options.headers
-    };
-    const response = await fetch(url, {
-      ...options,
-      headers
-    });
-    if (response.status === 401 && this.authenticated) {
-      await this.authenticate();
-      const retryHeaders = {
-        ...headers,
-        Authorization: `Bearer ${this.accessToken}`
-      };
-      return fetch(url, {
-        ...options,
-        headers: retryHeaders
-      });
-    }
-    return response;
-  }
-  async authenticate() {
-    try {
-      const now = Date.now();
-      if (this.accessToken && now < this.tokenExpiry) {
-        return;
-      }
-      const authUrl = "https://www.reddit.com/api/v1/access_token";
-      const authData = new URLSearchParams();
-      if (this.username && this.password) {
-        authData.append("grant_type", "password");
-        authData.append("username", this.username);
-        authData.append("password", this.password);
-      } else {
-        authData.append("grant_type", "client_credentials");
-      }
-      const credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
-      const response = await fetch(authUrl, {
-        method: "POST",
-        headers: {
-          "User-Agent": this.userAgent,
-          "Content-Type": "application/x-www-form-urlencoded",
-          Authorization: `Basic ${credentials}`
-        },
-        body: authData.toString()
-      });
-      if (!response.ok) {
-        throw new Error(`Authentication failed: ${response.status}`);
-      }
-      const data = await response.json();
-      this.accessToken = data.access_token;
-      this.tokenExpiry = now + data.expires_in * 1e3;
-      this.authenticated = true;
-    } catch {
-      throw new Error("Failed to authenticate with Reddit API");
-    }
-  }
-  async checkAuthentication() {
-    if (!this.authenticated) {
-      try {
-        await this.authenticate();
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return true;
-  }
-  async getUser(username) {
-    await this.authenticate();
-    try {
-      const response = await this.makeRequest(`/user/${username}/about.json`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      const data = json.data;
-      return {
-        name: data.name,
-        id: data.id,
-        commentKarma: data.comment_karma,
-        linkKarma: data.link_karma,
-        totalKarma: data.total_karma || data.comment_karma + data.link_karma,
-        isMod: data.is_mod,
-        isGold: data.is_gold,
-        isEmployee: data.is_employee,
-        createdUtc: data.created_utc,
-        profileUrl: `https://reddit.com/user/${data.name}`
-      };
-    } catch {
-      throw new Error(`Failed to get user info for ${username}`);
-    }
-  }
-  async getSubredditInfo(subredditName) {
-    await this.authenticate();
-    try {
-      const response = await this.makeRequest(`/r/${subredditName}/about.json`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      const data = json.data;
-      return {
-        displayName: data.display_name,
-        title: data.title,
-        description: data.description || "",
-        publicDescription: data.public_description || "",
-        subscribers: data.subscribers,
-        activeUserCount: data.active_user_count ?? void 0,
-        createdUtc: data.created_utc,
-        over18: data.over18,
-        subredditType: data.subreddit_type,
-        url: data.url
-      };
-    } catch {
-      throw new Error(`Failed to get subreddit info for ${subredditName}`);
-    }
-  }
-  async getTopPosts(subreddit, timeFilter = "week", limit = 10) {
-    await this.authenticate();
-    try {
-      const endpoint = subreddit ? `/r/${subreddit}/top.json` : "/top.json";
-      const params = new URLSearchParams({
-        t: timeFilter,
-        limit: limit.toString()
-      });
-      const response = await this.makeRequest(`${endpoint}?${params}`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      return json.data.children.map((child) => {
-        const post = child.data;
-        return {
-          id: post.id,
-          title: post.title,
-          author: post.author,
-          subreddit: post.subreddit,
-          selftext: post.selftext,
-          url: post.url,
-          score: post.score,
-          upvoteRatio: post.upvote_ratio,
-          numComments: post.num_comments,
-          createdUtc: post.created_utc,
-          over18: post.over_18,
-          spoiler: post.spoiler,
-          edited: !!post.edited,
-          isSelf: post.is_self,
-          linkFlairText: post.link_flair_text ?? void 0,
-          permalink: post.permalink
-        };
-      });
-    } catch {
-      throw new Error(`Failed to get top posts for ${subreddit || "home"}`);
-    }
-  }
-  async getPost(postId, subreddit) {
-    await this.authenticate();
-    try {
-      const endpoint = subreddit ? `/r/${subreddit}/comments/${postId}.json` : `/api/info.json?id=t3_${postId}`;
-      const response = await this.makeRequest(endpoint);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      let post;
-      if (subreddit) {
-        post = json[0].data.children[0].data;
-      } else {
-        if (!json.data.children.length) {
-          throw new Error(`Post with ID ${postId} not found`);
-        }
-        post = json.data.children[0].data;
-      }
-      return {
-        id: post.id,
-        title: post.title,
-        author: post.author,
-        subreddit: post.subreddit,
-        selftext: post.selftext,
-        url: post.url,
-        score: post.score,
-        upvoteRatio: post.upvote_ratio,
-        numComments: post.num_comments,
-        createdUtc: post.created_utc,
-        over18: post.over_18,
-        spoiler: post.spoiler,
-        edited: !!post.edited,
-        isSelf: post.is_self,
-        linkFlairText: post.link_flair_text,
-        permalink: post.permalink
-      };
-    } catch {
-      throw new Error(`Failed to get post with ID ${postId}`);
-    }
-  }
-  async getTrendingSubreddits(limit = 5) {
-    await this.authenticate();
-    try {
-      const params = new URLSearchParams({ limit: limit.toString() });
-      const response = await this.makeRequest(`/subreddits/popular.json?${params}`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      return json.data.children.map((child) => child.data.display_name);
-    } catch {
-      throw new Error("Failed to get trending subreddits");
-    }
-  }
-  async createPost(subreddit, title, content, isSelf = true) {
-    await this.authenticate();
-    if (!this.username || !this.password) {
-      throw new Error("User authentication required for posting");
-    }
-    try {
-      const kind = isSelf ? "self" : "link";
-      const params = new URLSearchParams();
-      params.append("sr", subreddit);
-      params.append("kind", kind);
-      params.append("title", title);
-      params.append(isSelf ? "text" : "url", content);
-      const response = await this.makeRequest("/api/submit", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: params.toString()
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      if (json.success) {
-        const postId = json.data.id;
-        return await this.getPost(postId);
-      } else {
-        throw new Error("Failed to create post");
-      }
-    } catch {
-      throw new Error(`Failed to create post in ${subreddit}`);
-    }
-  }
-  async checkPostExists(postId) {
-    await this.authenticate();
-    try {
-      const response = await this.makeRequest(`/api/info.json?id=t3_${postId}`);
-      if (!response.ok) {
-        return false;
-      }
-      const json = await response.json();
-      return json.data.children.length > 0;
-    } catch {
-      return false;
-    }
-  }
-  async replyToPost(postId, content) {
-    await this.authenticate();
-    if (!this.username || !this.password) {
-      throw new Error("User authentication required for posting replies");
-    }
-    try {
-      if (!await this.checkPostExists(postId)) {
-        throw new Error(`Post with ID ${postId} does not exist or is not accessible`);
-      }
-      const params = new URLSearchParams();
-      params.append("thing_id", `t3_${postId}`);
-      params.append("text", content);
-      const response = await this.makeRequest("/api/comment", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        body: params.toString()
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const commentData = await response.json();
-      return {
-        id: commentData.id,
-        author: this.username,
-        body: content,
-        score: 1,
-        controversiality: 0,
-        subreddit: commentData.subreddit,
-        submissionTitle: commentData.link_title,
-        createdUtc: Date.now() / 1e3,
-        edited: false,
-        isSubmitter: false,
-        permalink: commentData.permalink
-      };
-    } catch {
-      throw new Error(`Failed to reply to post ${postId}`);
-    }
-  }
-  async searchReddit(query, options = {}) {
-    await this.authenticate();
-    try {
-      const { subreddit, sort = "relevance", timeFilter = "all", limit = 25, type = "link" } = options;
-      const endpoint = subreddit ? `/r/${subreddit}/search.json` : "/search.json";
-      const params = new URLSearchParams({
-        q: query,
-        sort,
-        t: timeFilter,
-        limit: limit.toString(),
-        type,
-        ...subreddit && { restrict_sr: "true" }
-      });
-      const response = await this.makeRequest(`${endpoint}?${params}`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      return json.data.children.filter((child) => child.kind === "t3").map((child) => {
-        const post = child.data;
-        return {
-          id: post.id,
-          title: post.title,
-          author: post.author,
-          subreddit: post.subreddit,
-          selftext: post.selftext || "",
-          url: post.url,
-          score: post.score,
-          upvoteRatio: post.upvote_ratio,
-          numComments: post.num_comments,
-          createdUtc: post.created_utc,
-          over18: post.over_18,
-          spoiler: post.spoiler,
-          edited: !!post.edited,
-          isSelf: post.is_self,
-          linkFlairText: post.link_flair_text ?? void 0,
-          permalink: post.permalink
-        };
-      });
-    } catch {
-      throw new Error(`Failed to search Reddit for: ${query}`);
-    }
-  }
-  async getPostComments(postId, subreddit, options = {}) {
-    await this.authenticate();
-    try {
-      const { sort = "best", limit = 100 } = options;
-      const params = new URLSearchParams({
-        sort,
-        limit: limit.toString()
-      });
-      const response = await this.makeRequest(`/r/${subreddit}/comments/${postId}.json?${params}`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      const postData = json[0].data.children[0].data;
-      const post = {
-        id: postData.id,
-        title: postData.title,
-        author: postData.author,
-        subreddit: postData.subreddit,
-        selftext: postData.selftext || "",
-        url: postData.url,
-        score: postData.score,
-        upvoteRatio: postData.upvote_ratio,
-        numComments: postData.num_comments,
-        createdUtc: postData.created_utc,
-        over18: postData.over_18,
-        spoiler: postData.spoiler,
-        edited: !!postData.edited,
-        isSelf: postData.is_self,
-        linkFlairText: postData.link_flair_text,
-        permalink: postData.permalink
-      };
-      const comments = [];
-      const parseComments = (commentData, depth = 0) => {
-        for (const item of commentData) {
-          if (item.kind === "t1" && item.data.body) {
-            comments.push({
-              id: item.data.id,
-              author: item.data.author,
-              body: item.data.body,
-              score: item.data.score,
-              controversiality: item.data.controversiality,
-              subreddit: item.data.subreddit,
-              submissionTitle: post.title,
-              createdUtc: item.data.created_utc,
-              edited: !!item.data.edited,
-              isSubmitter: item.data.is_submitter,
-              permalink: item.data.permalink,
-              depth,
-              parentId: item.data.parent_id
-            });
-            if (item.data.replies && item.data.replies.data && item.data.replies.data.children) {
-              parseComments(item.data.replies.data.children, depth + 1);
-            }
-          }
-        }
-      };
-      if (json[1] && json[1].data && json[1].data.children) {
-        parseComments(json[1].data.children);
-      }
-      return { post, comments };
-    } catch {
-      throw new Error(`Failed to get comments for post ${postId}`);
-    }
-  }
-  async getUserPosts(username, options = {}) {
-    await this.authenticate();
-    try {
-      const { sort = "new", timeFilter = "all", limit = 25 } = options;
-      const params = new URLSearchParams({
-        sort,
-        t: timeFilter,
-        limit: limit.toString()
-      });
-      const response = await this.makeRequest(`/user/${username}/submitted.json?${params}`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      return json.data.children.filter((child) => child.kind === "t3").map((child) => {
-        const post = child.data;
-        return {
-          id: post.id,
-          title: post.title,
-          author: post.author,
-          subreddit: post.subreddit,
-          selftext: post.selftext || "",
-          url: post.url,
-          score: post.score,
-          upvoteRatio: post.upvote_ratio,
-          numComments: post.num_comments,
-          createdUtc: post.created_utc,
-          over18: post.over_18,
-          spoiler: post.spoiler,
-          edited: !!post.edited,
-          isSelf: post.is_self,
-          linkFlairText: post.link_flair_text ?? void 0,
-          permalink: post.permalink
-        };
-      });
-    } catch {
-      throw new Error(`Failed to get posts for user ${username}`);
-    }
-  }
-  async getUserComments(username, options = {}) {
-    await this.authenticate();
-    try {
-      const { sort = "new", timeFilter = "all", limit = 25 } = options;
-      const params = new URLSearchParams({
-        sort,
-        t: timeFilter,
-        limit: limit.toString()
-      });
-      const response = await this.makeRequest(`/user/${username}/comments.json?${params}`);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const json = await response.json();
-      return json.data.children.filter((child) => child.kind === "t1").map((child) => {
-        const comment = child.data;
-        return {
-          id: comment.id,
-          author: comment.author,
-          body: comment.body,
-          score: comment.score,
-          controversiality: comment.controversiality,
-          subreddit: comment.subreddit,
-          submissionTitle: comment.link_title || "",
-          createdUtc: comment.created_utc,
-          edited: !!comment.edited,
-          isSubmitter: comment.is_submitter,
-          permalink: comment.permalink
-        };
-      });
-    } catch {
-      throw new Error(`Failed to get comments for user ${username}`);
-    }
-  }
+	clientId;
+	clientSecret;
+	userAgent;
+	username;
+	password;
+	accessToken;
+	tokenExpiry = 0;
+	baseUrl;
+	authenticated = false;
+	authMode;
+	hasCredentials;
+	safeMode;
+	lastWriteTime = 0;
+	recentContentHashes = /* @__PURE__ */ new Set();
+	constructor(config) {
+		this.clientId = config.clientId;
+		this.clientSecret = config.clientSecret;
+		this.userAgent = config.userAgent;
+		this.username = config.username;
+		this.password = config.password;
+		this.authMode = config.authMode || "auto";
+		this.hasCredentials = !!(this.clientId && this.clientSecret);
+		this.baseUrl = this.determineBaseUrl();
+		this.safeMode = config.safeMode || {
+			enabled: false,
+			mode: "off",
+			writeDelayMs: 0,
+			duplicateCheck: false,
+			maxRecentHashes: 10
+		};
+	}
+	determineBaseUrl() {
+		switch (this.authMode) {
+			case "authenticated": return "https://oauth.reddit.com";
+			case "anonymous": return "https://www.reddit.com";
+			case "auto": return this.hasCredentials ? "https://oauth.reddit.com" : "https://www.reddit.com";
+		}
+	}
+	async makeRequest(path, options = {}) {
+		const requiresAuth = this.authMode === "authenticated" || this.authMode === "auto" && this.hasCredentials;
+		if (requiresAuth && (Date.now() >= this.tokenExpiry || !this.authenticated)) await this.authenticate();
+		const url = `${this.baseUrl}${path}`;
+		const headers = {
+			"User-Agent": this.userAgent,
+			...options.headers
+		};
+		if (requiresAuth && this.accessToken) headers.Authorization = `Bearer ${this.accessToken}`;
+		const response = await fetch(url, {
+			...options,
+			headers
+		});
+		if (response.status === 401 && this.authenticated) {
+			await this.authenticate();
+			const retryHeaders = {
+				...headers,
+				Authorization: `Bearer ${this.accessToken}`
+			};
+			return fetch(url, {
+				...options,
+				headers: retryHeaders
+			});
+		}
+		return response;
+	}
+	async authenticate() {
+		if (this.authMode === "anonymous") {
+			this.authenticated = false;
+			return;
+		}
+		if (this.authMode === "authenticated" && !this.hasCredentials) throw new Error("Authenticated mode requires REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET");
+		if (this.authMode === "auto" && !this.hasCredentials) {
+			this.authenticated = false;
+			return;
+		}
+		try {
+			const now = Date.now();
+			if (this.accessToken && now < this.tokenExpiry) return;
+			const authUrl = "https://www.reddit.com/api/v1/access_token";
+			const authData = new URLSearchParams();
+			const username = this.username;
+			const password = this.password;
+			if (!!(username && password)) {
+				authData.append("grant_type", "password");
+				authData.append("username", username);
+				authData.append("password", password);
+			} else authData.append("grant_type", "client_credentials");
+			const credentials = Buffer.from(`${this.clientId}:${this.clientSecret}`).toString("base64");
+			const response = await fetch(authUrl, {
+				method: "POST",
+				headers: {
+					"User-Agent": this.userAgent,
+					"Content-Type": "application/x-www-form-urlencoded",
+					Authorization: `Basic ${credentials}`
+				},
+				body: authData.toString()
+			});
+			if (!response.ok) {
+				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 (error) {
+			if (error instanceof Error) throw error;
+			throw new Error("Failed to authenticate with Reddit API");
+		}
+	}
+	async checkAuthentication() {
+		if (!this.authenticated) try {
+			await this.authenticate();
+			return true;
+		} catch {
+			return false;
+		}
+		return true;
+	}
+	validateWriteAccess() {
+		if (!this.username || !this.password) {
+			if (this.authMode === "anonymous") throw new Error("Write operations not available in anonymous mode. Set REDDIT_USERNAME, REDDIT_PASSWORD and use 'auto' or 'authenticated' mode.");
+			throw new Error("Write operations require REDDIT_USERNAME and REDDIT_PASSWORD");
+		}
+	}
+	async enforceWriteRateLimit() {
+		if (!this.safeMode.enabled || this.safeMode.writeDelayMs <= 0) return;
+		const elapsed = Date.now() - this.lastWriteTime;
+		if (elapsed < this.safeMode.writeDelayMs) {
+			const waitTime = this.safeMode.writeDelayMs - elapsed;
+			console.error(`[SafeMode] Rate limit: waiting ${waitTime}ms before write operation`);
+			await new Promise((resolve) => setTimeout(resolve, waitTime));
+		}
+		this.lastWriteTime = Date.now();
+	}
+	hashContent(content) {
+		return crypto.default.createHash("md5").update(content.trim().toLowerCase()).digest("hex");
+	}
+	checkDuplicateContent(content) {
+		if (!this.safeMode.enabled || !this.safeMode.duplicateCheck) return;
+		const hash = this.hashContent(content);
+		if (this.recentContentHashes.has(hash)) throw new Error("Duplicate content detected. Reddit's spam filter may ban your account for posting identical content. Please modify your content and try again.");
+		this.recentContentHashes.add(hash);
+		if (this.recentContentHashes.size > this.safeMode.maxRecentHashes) {
+			const first = this.recentContentHashes.values().next().value;
+			if (first) this.recentContentHashes.delete(first);
+		}
+	}
+	async getUser(username) {
+		try {
+			const response = await this.makeRequest(`/user/${username}/about.json`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			const data = (await response.json()).data;
+			return {
+				name: data.name,
+				id: data.id,
+				commentKarma: data.comment_karma,
+				linkKarma: data.link_karma,
+				totalKarma: data.total_karma || data.comment_karma + data.link_karma,
+				isMod: data.is_mod,
+				isGold: data.is_gold,
+				isEmployee: data.is_employee,
+				createdUtc: data.created_utc,
+				profileUrl: `https://reddit.com/user/${data.name}`
+			};
+		} catch {
+			throw new Error(`Failed to get user info for ${username}`);
+		}
+	}
+	async getSubredditInfo(subredditName) {
+		try {
+			const response = await this.makeRequest(`/r/${subredditName}/about.json`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			const data = (await response.json()).data;
+			return {
+				displayName: data.display_name,
+				title: data.title,
+				description: data.description || "",
+				publicDescription: data.public_description || "",
+				subscribers: data.subscribers,
+				activeUserCount: data.active_user_count ?? void 0,
+				createdUtc: data.created_utc,
+				over18: data.over18,
+				subredditType: data.subreddit_type,
+				url: data.url
+			};
+		} catch {
+			throw new Error(`Failed to get subreddit info for ${subredditName}`);
+		}
+	}
+	async getTopPosts(subreddit, timeFilter = "week", limit = 10) {
+		try {
+			const endpoint = subreddit ? `/r/${subreddit}/top.json` : "/top.json";
+			const params = new URLSearchParams({
+				t: timeFilter,
+				limit: limit.toString()
+			});
+			const response = await this.makeRequest(`${endpoint}?${params}`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			return (await response.json()).data.children.map((child) => {
+				const post = child.data;
+				return {
+					id: post.id,
+					title: post.title,
+					author: post.author,
+					subreddit: post.subreddit,
+					selftext: post.selftext,
+					url: post.url,
+					score: post.score,
+					upvoteRatio: post.upvote_ratio,
+					numComments: post.num_comments,
+					createdUtc: post.created_utc,
+					over18: post.over_18,
+					spoiler: post.spoiler,
+					edited: !!post.edited,
+					isSelf: post.is_self,
+					linkFlairText: post.link_flair_text ?? void 0,
+					permalink: post.permalink
+				};
+			});
+		} catch {
+			throw new Error(`Failed to get top posts for ${subreddit || "home"}`);
+		}
+	}
+	async getPost(postId, subreddit) {
+		try {
+			const endpoint = subreddit ? `/r/${subreddit}/comments/${postId}.json` : `/api/info.json?id=t3_${postId}`;
+			const response = await this.makeRequest(endpoint);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			let post;
+			if (subreddit) post = (await response.json())[0].data.children[0].data;
+			else {
+				const json = await response.json();
+				if (!json.data.children.length) throw new Error(`Post with ID ${postId} not found`);
+				post = json.data.children[0].data;
+			}
+			return {
+				id: post.id,
+				title: post.title,
+				author: post.author,
+				subreddit: post.subreddit,
+				selftext: post.selftext,
+				url: post.url,
+				score: post.score,
+				upvoteRatio: post.upvote_ratio,
+				numComments: post.num_comments,
+				createdUtc: post.created_utc,
+				over18: post.over_18,
+				spoiler: post.spoiler,
+				edited: !!post.edited,
+				isSelf: post.is_self,
+				linkFlairText: post.link_flair_text ?? void 0,
+				permalink: post.permalink
+			};
+		} catch {
+			throw new Error(`Failed to get post with ID ${postId}`);
+		}
+	}
+	async getTrendingSubreddits(limit = 5) {
+		try {
+			const params = new URLSearchParams({ limit: limit.toString() });
+			const response = await this.makeRequest(`/subreddits/popular.json?${params}`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			return (await response.json()).data.children.map((child) => child.data.display_name);
+		} catch {
+			throw new Error("Failed to get trending subreddits");
+		}
+	}
+	async createPost(subreddit, title, content, isSelf = true) {
+		this.validateWriteAccess();
+		await this.enforceWriteRateLimit();
+		this.checkDuplicateContent(title + content);
+		try {
+			var _json$json, _json$json2, _json$json3;
+			const kind = isSelf ? "self" : "link";
+			const params = new URLSearchParams();
+			params.append("sr", subreddit);
+			params.append("kind", kind);
+			params.append("title", title);
+			params.append(isSelf ? "text" : "url", content);
+			params.append("api_type", "json");
+			const response = await this.makeRequest("/api/submit", {
+				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] 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();
+			console.error(`[Reddit API] Create post response:`, JSON.stringify(json, null, 2));
+			if (((_json$json = json.json) === null || _json$json === void 0 ? void 0 : _json$json.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}`);
+			}
+			const postId = ((_json$json2 = json.json) === null || _json$json2 === void 0 || (_json$json2 = _json$json2.data) === null || _json$json2 === void 0 ? void 0 : _json$json2.id) || ((_json$json3 = json.json) === null || _json$json3 === void 0 || (_json$json3 = _json$json3.data) === null || _json$json3 === void 0 || (_json$json3 = _json$json3.name) === null || _json$json3 === void 0 ? void 0 : _json$json3.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) {
+		try {
+			const response = await this.makeRequest(`/api/info.json?id=t3_${postId}`);
+			if (!response.ok) return false;
+			return (await response.json()).data.children.length > 0;
+		} catch {
+			return false;
+		}
+	}
+	async replyToPost(postId, content) {
+		this.validateWriteAccess();
+		await this.enforceWriteRateLimit();
+		this.checkDuplicateContent(content);
+		try {
+			var _json$json4, _json$json5;
+			if (!await this.checkPostExists(postId)) throw new Error(`Post with ID ${postId} does not exist or is not accessible`);
+			const params = new URLSearchParams();
+			params.append("thing_id", `t3_${postId}`);
+			params.append("text", content);
+			params.append("api_type", "json");
+			const response = await this.makeRequest("/api/comment", {
+				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] Reply to 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();
+			console.error(`[Reddit API] Reply response:`, JSON.stringify(json, null, 2));
+			if (((_json$json4 = json.json) === null || _json$json4 === void 0 || (_json$json4 = _json$json4.data) === null || _json$json4 === void 0 ? void 0 : _json$json4.things) && json.json.data.things.length > 0) {
+				const commentData = json.json.data.things[0].data;
+				const author = this.username ?? "[unknown]";
+				return {
+					id: commentData.id,
+					author,
+					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$json5 = json.json) === null || _json$json5 === void 0 ? void 0 : _json$json5.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) {
+		this.validateWriteAccess();
+		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) {
+		this.validateWriteAccess();
+		await this.enforceWriteRateLimit();
+		this.checkDuplicateContent(newText);
+		try {
+			var _json$json6;
+			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 (((_json$json6 = json.json) === null || _json$json6 === void 0 ? void 0 : _json$json6.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 = {}) {
+		try {
+			const { subreddit, sort = "relevance", timeFilter = "all", limit = 25, type = "link" } = options;
+			const endpoint = subreddit ? `/r/${subreddit}/search.json` : "/search.json";
+			const params = new URLSearchParams({
+				q: query,
+				sort,
+				t: timeFilter,
+				limit: limit.toString(),
+				type,
+				...subreddit && { restrict_sr: "true" }
+			});
+			const response = await this.makeRequest(`${endpoint}?${params}`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			return (await response.json()).data.children.filter((child) => child.kind === "t3").map((child) => {
+				const post = child.data;
+				return {
+					id: post.id,
+					title: post.title,
+					author: post.author,
+					subreddit: post.subreddit,
+					selftext: post.selftext || "",
+					url: post.url,
+					score: post.score,
+					upvoteRatio: post.upvote_ratio,
+					numComments: post.num_comments,
+					createdUtc: post.created_utc,
+					over18: post.over_18,
+					spoiler: post.spoiler,
+					edited: !!post.edited,
+					isSelf: post.is_self,
+					linkFlairText: post.link_flair_text ?? void 0,
+					permalink: post.permalink
+				};
+			});
+		} catch {
+			throw new Error(`Failed to search Reddit for: ${query}`);
+		}
+	}
+	async getPostComments(postId, subreddit, options = {}) {
+		try {
+			var _json$;
+			const { sort = "best", limit = 100 } = options;
+			const params = new URLSearchParams({
+				sort,
+				limit: limit.toString()
+			});
+			const response = await this.makeRequest(`/r/${subreddit}/comments/${postId}.json?${params}`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			const json = await response.json();
+			const postData = json[0].data.children[0].data;
+			const post = {
+				id: postData.id,
+				title: postData.title,
+				author: postData.author,
+				subreddit: postData.subreddit,
+				selftext: postData.selftext || "",
+				url: postData.url,
+				score: postData.score,
+				upvoteRatio: postData.upvote_ratio,
+				numComments: postData.num_comments,
+				createdUtc: postData.created_utc,
+				over18: postData.over_18,
+				spoiler: postData.spoiler,
+				edited: !!postData.edited,
+				isSelf: postData.is_self,
+				linkFlairText: postData.link_flair_text ?? void 0,
+				permalink: postData.permalink
+			};
+			const comments = [];
+			const parseComments = (commentData, depth = 0) => {
+				for (const item of commentData) if (item.kind === "t1" && item.data.body) {
+					var _replies$data;
+					comments.push({
+						id: item.data.id,
+						author: item.data.author,
+						body: item.data.body,
+						score: item.data.score,
+						controversiality: item.data.controversiality,
+						subreddit: item.data.subreddit,
+						submissionTitle: post.title,
+						createdUtc: item.data.created_utc,
+						edited: !!item.data.edited,
+						isSubmitter: item.data.is_submitter,
+						permalink: item.data.permalink,
+						depth,
+						parentId: item.data.parent_id
+					});
+					const replies = item.data.replies;
+					if (replies && typeof replies !== "string" && ((_replies$data = replies.data) === null || _replies$data === void 0 ? void 0 : _replies$data.children)) parseComments(replies.data.children, depth + 1);
+				}
+			};
+			if ((_json$ = json[1]) === null || _json$ === void 0 || (_json$ = _json$.data) === null || _json$ === void 0 ? void 0 : _json$.children) parseComments(json[1].data.children);
+			return {
+				post,
+				comments
+			};
+		} catch {
+			throw new Error(`Failed to get comments for post ${postId}`);
+		}
+	}
+	async getUserPosts(username, options = {}) {
+		try {
+			const { sort = "new", timeFilter = "all", limit = 25 } = options;
+			const params = new URLSearchParams({
+				sort,
+				t: timeFilter,
+				limit: limit.toString()
+			});
+			const response = await this.makeRequest(`/user/${username}/submitted.json?${params}`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			return (await response.json()).data.children.filter((child) => child.kind === "t3").map((child) => {
+				const post = child.data;
+				return {
+					id: post.id,
+					title: post.title,
+					author: post.author,
+					subreddit: post.subreddit,
+					selftext: post.selftext || "",
+					url: post.url,
+					score: post.score,
+					upvoteRatio: post.upvote_ratio,
+					numComments: post.num_comments,
+					createdUtc: post.created_utc,
+					over18: post.over_18,
+					spoiler: post.spoiler,
+					edited: !!post.edited,
+					isSelf: post.is_self,
+					linkFlairText: post.link_flair_text ?? void 0,
+					permalink: post.permalink
+				};
+			});
+		} catch {
+			throw new Error(`Failed to get posts for user ${username}`);
+		}
+	}
+	async getUserComments(username, options = {}) {
+		try {
+			const { sort = "new", timeFilter = "all", limit = 25 } = options;
+			const params = new URLSearchParams({
+				sort,
+				t: timeFilter,
+				limit: limit.toString()
+			});
+			const response = await this.makeRequest(`/user/${username}/comments.json?${params}`);
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			return (await response.json()).data.children.filter((child) => child.kind === "t1").map((child) => {
+				const comment = child.data;
+				return {
+					id: comment.id,
+					author: comment.author,
+					body: comment.body ?? "",
+					score: comment.score,
+					controversiality: comment.controversiality,
+					subreddit: comment.subreddit,
+					submissionTitle: comment.link_title ?? "",
+					createdUtc: comment.created_utc,
+					edited: !!comment.edited,
+					isSubmitter: comment.is_submitter,
+					permalink: comment.permalink
+				};
+			});
+		} catch {
+			throw new Error(`Failed to get comments for user ${username}`);
+		}
+	}
 };
-var redditClient = null;
+let redditClient = null;
 function initializeRedditClient(config) {
-  redditClient = new RedditClient(config);
-  return redditClient;
+	redditClient = new RedditClient(config);
+	return redditClient;
 }
 function getRedditClient() {
-  return redditClient;
+	return redditClient;
 }
 
-// src/utils/formatters.ts
+//#endregion
+//#region src/utils/formatters.ts
 function formatTimestamp(timestamp) {
-  try {
-    const date = new Date(timestamp * 1e3);
-    return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
-  } catch {
-    return String(timestamp);
-  }
+	try {
+		return (/* @__PURE__ */ new Date(timestamp * 1e3)).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
+	} catch {
+		return String(timestamp);
+	}
 }
 function analyzeUserActivity(karmaRatio, isMod, accountAgeDays) {
-  const insights = [];
-  if (karmaRatio > 5) {
-    insights.push("Primarily a commenter, highly engaged in discussions");
-  } else if (karmaRatio < 0.2) {
-    insights.push("Content creator, focuses on sharing posts");
-  } else {
-    insights.push("Balanced participation in both posting and commenting");
-  }
-  if (accountAgeDays < 30) {
-    insights.push("New user, still exploring Reddit");
-  } else if (accountAgeDays > 365 * 5) {
-    insights.push("Long-time Redditor with extensive platform experience");
-  }
-  if (isMod) {
-    insights.push("Community leader who helps maintain subreddit quality");
-  }
-  return insights.join("\n  - ");
+	const insights = [];
+	if (karmaRatio > 5) insights.push("Primarily a commenter, highly engaged in discussions");
+	else if (karmaRatio < .2) insights.push("Content creator, focuses on sharing posts");
+	else insights.push("Balanced participation in both posting and commenting");
+	if (accountAgeDays < 30) insights.push("New user, still exploring Reddit");
+	else if (accountAgeDays > 365 * 5) insights.push("Long-time Redditor with extensive platform experience");
+	if (isMod) insights.push("Community leader who helps maintain subreddit quality");
+	return insights.join("\n  - ");
 }
 function analyzePostEngagement(score, ratio, numComments) {
-  const insights = [];
-  if (score > 1e3 && ratio > 0.95) {
-    insights.push("Highly successful post with strong community approval");
-  } else if (score > 100 && ratio > 0.8) {
-    insights.push("Well-received post with good engagement");
-  } else if (ratio < 0.5) {
-    insights.push("Controversial post that sparked debate");
-  }
-  if (numComments > 100) {
-    insights.push("Generated significant discussion");
-  } else if (numComments > score * 0.5) {
-    insights.push("Highly discussable content with active comment section");
-  } else if (numComments === 0) {
-    insights.push("Yet to receive community interaction");
-  }
-  return insights.join("\n  - ");
+	const insights = [];
+	if (score > 1e3 && ratio > .95) insights.push("Highly successful post with strong community approval");
+	else if (score > 100 && ratio > .8) insights.push("Well-received post with good engagement");
+	else if (ratio < .5) insights.push("Controversial post that sparked debate");
+	if (numComments > 100) insights.push("Generated significant discussion");
+	else if (numComments > score * .5) insights.push("Highly discussable content with active comment section");
+	else if (numComments === 0) insights.push("Yet to receive community interaction");
+	return insights.join("\n  - ");
 }
 function analyzeSubredditHealth(subscribers, activeUsers, ageDays) {
-  const insights = [];
-  if (subscribers > 1e6) {
-    insights.push("Major subreddit with massive following");
-  } else if (subscribers > 1e5) {
-    insights.push("Well-established community");
-  } else if (subscribers < 1e3) {
-    insights.push("Niche community, potential for growth");
-  }
-  if (activeUsers) {
-    const activityRatio = activeUsers / subscribers;
-    if (activityRatio > 0.1) {
-      insights.push("Highly active community with strong engagement");
-    } else if (activityRatio < 0.01) {
-      insights.push("Could benefit from more community engagement initiatives");
-    }
-  }
-  if (ageDays > 365 * 5) {
-    insights.push("Mature subreddit with established culture");
-  } else if (ageDays < 90) {
-    insights.push("New subreddit still forming its community");
-  }
-  return insights.join("\n  - ");
+	const insights = [];
+	if (subscribers > 1e6) insights.push("Major subreddit with massive following");
+	else if (subscribers > 1e5) insights.push("Well-established community");
+	else if (subscribers < 1e3) insights.push("Niche community, potential for growth");
+	if (activeUsers) {
+		const activityRatio = activeUsers / subscribers;
+		if (activityRatio > .1) insights.push("Highly active community with strong engagement");
+		else if (activityRatio < .01) insights.push("Could benefit from more community engagement initiatives");
+	}
+	if (ageDays > 365 * 5) insights.push("Mature subreddit with established culture");
+	else if (ageDays < 90) insights.push("New subreddit still forming its community");
+	return insights.join("\n  - ");
 }
 function getUserRecommendations(karmaRatio, isMod, accountAgeDays) {
-  const recommendations = [];
-  if (karmaRatio > 5) {
-    recommendations.push("Consider creating more posts to share your expertise");
-  } else if (karmaRatio < 0.2) {
-    recommendations.push("Engage more in discussions to build community connections");
-  }
-  if (accountAgeDays < 30) {
-    recommendations.push("Explore popular subreddits in your areas of interest");
-    recommendations.push("Read community guidelines before posting");
-  }
-  if (isMod) {
-    recommendations.push("Share moderation insights with other community leaders");
-  }
-  if (!recommendations.length) {
-    recommendations.push("Maintain your balanced engagement across Reddit");
-  }
-  return recommendations.join("\n  - ");
+	const recommendations = [];
+	if (karmaRatio > 5) recommendations.push("Consider creating more posts to share your expertise");
+	else if (karmaRatio < .2) recommendations.push("Engage more in discussions to build community connections");
+	if (accountAgeDays < 30) {
+		recommendations.push("Explore popular subreddits in your areas of interest");
+		recommendations.push("Read community guidelines before posting");
+	}
+	if (isMod) recommendations.push("Share moderation insights with other community leaders");
+	if (!recommendations.length) recommendations.push("Maintain your balanced engagement across Reddit");
+	return recommendations.join("\n  - ");
 }
 function getBestEngagementTime(createdUtc) {
-  const postHour = new Date(createdUtc * 1e3).getHours();
-  if (14 <= postHour && postHour <= 18) {
-    return "Posted during peak engagement hours (2 PM - 6 PM), good timing!";
-  } else if (23 <= postHour || postHour <= 5) {
-    return "Consider posting during more active hours (morning to evening)";
-  } else {
-    return "Posted during moderate activity hours, timing could be optimized";
-  }
+	const postHour = (/* @__PURE__ */ new Date(createdUtc * 1e3)).getHours();
+	if (14 <= postHour && postHour <= 18) return "Posted during peak engagement hours (2 PM - 6 PM), good timing!";
+	else if (23 <= postHour || postHour <= 5) return "Consider posting during more active hours (morning to evening)";
+	else return "Posted during moderate activity hours, timing could be optimized";
 }
 function getSubredditEngagementTips(subreddit) {
-  const tips = [];
-  if (subreddit.subscribers > 1e6) {
-    tips.push("Post during peak hours for maximum visibility");
-    tips.push("Ensure content is highly polished due to high competition");
-  } else if (subreddit.subscribers < 1e3) {
-    tips.push("Engage actively to help grow the community");
-    tips.push("Consider cross-posting to related larger subreddits");
-  }
-  if (subreddit.activeUserCount) {
-    const activityRatio = subreddit.activeUserCount / subreddit.subscribers;
-    if (activityRatio > 0.1) {
-      tips.push("Quick responses recommended due to high activity");
-    }
-  }
-  return tips.length ? tips.join("\n  - ") : "Regular engagement recommended to maintain community presence";
+	const tips = [];
+	if (subreddit.subscribers > 1e6) {
+		tips.push("Post during peak hours for maximum visibility");
+		tips.push("Ensure content is highly polished due to high competition");
+	} else if (subreddit.subscribers < 1e3) {
+		tips.push("Engage actively to help grow the community");
+		tips.push("Consider cross-posting to related larger subreddits");
+	}
+	if (subreddit.activeUserCount) {
+		if (subreddit.activeUserCount / subreddit.subscribers > .1) tips.push("Quick responses recommended due to high activity");
+	}
+	return tips.length ? tips.join("\n  - ") : "Regular engagement recommended to maintain community presence";
 }
 function formatUserInfo(user) {
-  const status = [];
-  if (user.isMod) status.push("Moderator");
-  if (user.isGold) status.push("Reddit Gold Member");
-  if (user.isEmployee) status.push("Reddit Employee");
-  const accountAgeDays = (Date.now() / 1e3 - user.createdUtc) / (24 * 3600);
-  const karmaRatio = user.commentKarma / (user.linkKarma || 1);
-  return {
-    username: user.name,
-    karma: {
-      commentKarma: user.commentKarma,
-      postKarma: user.linkKarma,
-      totalKarma: user.totalKarma
-    },
-    accountStatus: status.length ? status : ["Regular User"],
-    accountCreated: formatTimestamp(user.createdUtc),
-    profileUrl: user.profileUrl,
-    activityAnalysis: analyzeUserActivity(karmaRatio, user.isMod, accountAgeDays),
-    recommendations: getUserRecommendations(karmaRatio, user.isMod, accountAgeDays)
-  };
+	const status = [];
+	if (user.isMod) status.push("Moderator");
+	if (user.isGold) status.push("Reddit Gold Member");
+	if (user.isEmployee) status.push("Reddit Employee");
+	const accountAgeDays = (Date.now() / 1e3 - user.createdUtc) / (24 * 3600);
+	const karmaRatio = user.commentKarma / (user.linkKarma || 1);
+	return {
+		username: user.name,
+		karma: {
+			commentKarma: user.commentKarma,
+			postKarma: user.linkKarma,
+			totalKarma: user.totalKarma
+		},
+		accountStatus: status.length ? status : ["Regular User"],
+		accountCreated: formatTimestamp(user.createdUtc),
+		profileUrl: user.profileUrl,
+		activityAnalysis: analyzeUserActivity(karmaRatio, user.isMod, accountAgeDays),
+		recommendations: getUserRecommendations(karmaRatio, user.isMod, accountAgeDays)
+	};
 }
 function formatPostInfo(post) {
-  const contentType = post.isSelf ? "Text Post" : "Link Post";
-  const content = post.isSelf ? post.selftext || "" : post.url || "";
-  const flags = [];
-  if (post.over18) flags.push("NSFW");
-  if (post.spoiler) flags.push("Spoiler");
-  if (post.edited) flags.push("Edited");
-  return {
-    title: post.title,
-    type: contentType,
-    content: content.length > 300 ? content.substring(0, 297) + "..." : content,
-    author: post.author,
-    subreddit: post.subreddit,
-    stats: {
-      score: post.score,
-      upvoteRatio: post.upvoteRatio,
-      comments: post.numComments
-    },
-    metadata: {
-      posted: formatTimestamp(post.createdUtc),
-      flags,
-      flair: post.linkFlairText || "None"
-    },
-    links: {
-      fullPost: `https://reddit.com${post.permalink}`,
-      shortLink: `https://redd.it/${post.id}`
-    },
-    engagementAnalysis: analyzePostEngagement(post.score, post.upvoteRatio, post.numComments),
-    bestTimeToEngage: getBestEngagementTime(post.createdUtc)
-  };
+	const contentType = post.isSelf ? "Text Post" : "Link Post";
+	const content = post.isSelf ? post.selftext || "" : post.url || "";
+	const flags = [];
+	if (post.over18) flags.push("NSFW");
+	if (post.spoiler) flags.push("Spoiler");
+	if (post.edited) flags.push("Edited");
+	return {
+		title: post.title,
+		type: contentType,
+		content: content.length > 300 ? content.substring(0, 297) + "..." : content,
+		author: post.author,
+		subreddit: post.subreddit,
+		stats: {
+			score: post.score,
+			upvoteRatio: post.upvoteRatio,
+			comments: post.numComments
+		},
+		metadata: {
+			posted: formatTimestamp(post.createdUtc),
+			flags,
+			flair: post.linkFlairText || "None"
+		},
+		links: {
+			fullPost: `https://reddit.com${post.permalink}`,
+			shortLink: `https://redd.it/${post.id}`
+		},
+		engagementAnalysis: analyzePostEngagement(post.score, post.upvoteRatio, post.numComments),
+		bestTimeToEngage: getBestEngagementTime(post.createdUtc)
+	};
 }
 function formatSubredditInfo(subreddit) {
-  const flags = [];
-  if (subreddit.over18) flags.push("NSFW");
-  if (subreddit.subredditType) flags.push(`Type: ${subreddit.subredditType}`);
-  const ageDays = (Date.now() / 1e3 - subreddit.createdUtc) / (24 * 3600);
-  return {
-    name: subreddit.displayName,
-    title: subreddit.title,
-    stats: {
-      subscribers: subreddit.subscribers,
-      activeUsers: subreddit.activeUserCount !== void 0 ? subreddit.activeUserCount : "Unknown"
-    },
-    description: {
-      short: subreddit.publicDescription,
-      full: subreddit.description.length > 300 ? subreddit.description.substring(0, 297) + "..." : subreddit.description
-    },
-    metadata: {
-      created: formatTimestamp(subreddit.createdUtc),
-      flags: flags.length ? flags : ["None"]
-    },
-    links: {
-      subreddit: `https://reddit.com${subreddit.url}`,
-      wiki: `https://reddit.com/r/${subreddit.displayName}/wiki`
-    },
-    communityAnalysis: analyzeSubredditHealth(subreddit.subscribers, subreddit.activeUserCount, ageDays),
-    engagementTips: getSubredditEngagementTips(subreddit)
-  };
+	const flags = [];
+	if (subreddit.over18) flags.push("NSFW");
+	if (subreddit.subredditType) flags.push(`Type: ${subreddit.subredditType}`);
+	const ageDays = (Date.now() / 1e3 - subreddit.createdUtc) / (24 * 3600);
+	return {
+		name: subreddit.displayName,
+		title: subreddit.title,
+		stats: {
+			subscribers: subreddit.subscribers,
+			activeUsers: subreddit.activeUserCount !== void 0 ? subreddit.activeUserCount : "Unknown"
+		},
+		description: {
+			short: subreddit.publicDescription,
+			full: subreddit.description.length > 300 ? subreddit.description.substring(0, 297) + "..." : subreddit.description
+		},
+		metadata: {
+			created: formatTimestamp(subreddit.createdUtc),
+			flags: flags.length ? flags : ["None"]
+		},
+		links: {
+			subreddit: `https://reddit.com${subreddit.url}`,
+			wiki: `https://reddit.com/r/${subreddit.displayName}/wiki`
+		},
+		communityAnalysis: analyzeSubredditHealth(subreddit.subscribers, subreddit.activeUserCount, ageDays),
+		engagementTips: getSubredditEngagementTips(subreddit)
+	};
 }
 
-// src/index.ts
-var import_dotenv = __toESM(require("dotenv"));
-import_dotenv.default.config();
+//#endregion
+//#region src/index.ts
+dotenv.default.config();
+function validateUserAgent(userAgent, username) {
+	if (!/^[\w-]+:[\w-]+:[\d.]+ \(by \/u\/\w+\)$/.test(userAgent)) {
+		console.error("[Warning] User-Agent does not follow Reddit's recommended format");
+		console.error("[Warning] Recommended: 'platform:app_id:version (by /u/username)'");
+		console.error("[Warning] Non-standard User-Agents may increase ban risk");
+		if (username) console.error(`[Warning] Consider using: 'typescript:reddit-mcp-server:1.2.0 (by /u/${username})'`);
+	}
+}
+function buildUserAgent(customAgent, username) {
+	if (customAgent) {
+		validateUserAgent(customAgent, username);
+		return customAgent;
+	}
+	if (username) {
+		const autoAgent = `typescript:reddit-mcp-server:1.2.0 (by /u/${username})`;
+		console.error(`[Setup] Auto-generated User-Agent: ${autoAgent}`);
+		return autoAgent;
+	}
+	const fallbackAgent = "RedditMCPServer/1.2.0";
+	validateUserAgent(fallbackAgent);
+	return fallbackAgent;
+}
+function buildSafeModeConfig(safeMode) {
+	switch (safeMode) {
+		case "off": return {
+			enabled: false,
+			mode: "off",
+			writeDelayMs: 0,
+			duplicateCheck: false,
+			maxRecentHashes: 10
+		};
+		case "standard": return {
+			enabled: true,
+			mode: "standard",
+			writeDelayMs: 2e3,
+			duplicateCheck: true,
+			maxRecentHashes: 10
+		};
+		case "strict": return {
+			enabled: true,
+			mode: "strict",
+			writeDelayMs: 5e3,
+			duplicateCheck: true,
+			maxRecentHashes: 20
+		};
+	}
+}
 async function setupRedditClient() {
-  const clientId = process.env.REDDIT_CLIENT_ID;
-  const clientSecret = process.env.REDDIT_CLIENT_SECRET;
-  const userAgent = process.env.REDDIT_USER_AGENT || "RedditMCPServer/1.1.0";
-  const username = process.env.REDDIT_USERNAME;
-  const password = process.env.REDDIT_PASSWORD;
-  if (!clientId || !clientSecret) {
-    console.error(
-      "[Error] Missing required Reddit API credentials. Please set REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET environment variables."
-    );
-    process.exit(1);
-  }
-  try {
-    initializeRedditClient({
-      clientId,
-      clientSecret,
-      userAgent,
-      username,
-      password
-    });
-    console.error("[Setup] Reddit client initialized");
-    if (username && password) {
-      console.error(`[Setup] Authenticated as user: ${username}`);
-    } else {
-      console.error("[Setup] Running in read-only mode (no user authentication)");
-    }
-  } catch (error) {
-    console.error("[Error] Failed to initialize Reddit client:", error);
-    process.exit(1);
-  }
+	const clientId = process.env.REDDIT_CLIENT_ID;
+	const clientSecret = process.env.REDDIT_CLIENT_SECRET;
+	const customUserAgent = process.env.REDDIT_USER_AGENT;
+	const username = process.env.REDDIT_USERNAME;
+	const password = process.env.REDDIT_PASSWORD;
+	const authMode = process.env.REDDIT_AUTH_MODE || "auto";
+	const safeMode = process.env.REDDIT_SAFE_MODE || "off";
+	if (![
+		"auto",
+		"authenticated",
+		"anonymous"
+	].includes(authMode)) {
+		console.error(`[Error] Invalid REDDIT_AUTH_MODE: ${authMode}`);
+		console.error("[Error] Valid options are: auto, authenticated, anonymous");
+		process.exit(1);
+	}
+	if (![
+		"off",
+		"standard",
+		"strict"
+	].includes(safeMode)) {
+		console.error(`[Error] Invalid REDDIT_SAFE_MODE: ${safeMode}`);
+		console.error("[Error] Valid options are: off, standard, strict");
+		process.exit(1);
+	}
+	if (authMode === "authenticated" && (!clientId || !clientSecret)) {
+		console.error("[Error] Authenticated mode requires REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET");
+		process.exit(1);
+	}
+	const hasCredentials = !!(clientId && clientSecret);
+	const userAgent = buildUserAgent(customUserAgent, username);
+	const safeModeConfig = buildSafeModeConfig(safeMode);
+	try {
+		const client = initializeRedditClient({
+			clientId: clientId || "",
+			clientSecret: clientSecret || "",
+			userAgent,
+			username,
+			password,
+			authMode,
+			safeMode: safeModeConfig
+		});
+		console.error("[Setup] Reddit client initialized");
+		console.error(`[Setup] Authentication mode: ${authMode}`);
+		if (authMode === "anonymous" || !hasCredentials) {
+			console.error("[Setup] Using anonymous Reddit API (~10 req/min)");
+			console.error("[Setup] No authentication required - ready to use!");
+		} else {
+			console.error("[Setup] Testing Reddit API connection...");
+			if (!await client.checkAuthentication()) {
+				console.error("[Error] ✗ 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] ✓ Reddit API connection successful");
+			console.error("[Setup] Using OAuth Reddit API (60-100 req/min)");
+		}
+		if (username && password) {
+			console.error(`[Setup] ✓ User authenticated as: ${username}`);
+			console.error("[Setup] Write operations enabled (posting, replying, editing, deleting)");
+		} else {
+			console.error("[Setup] Read-only mode (no user credentials)");
+			console.error("[Setup] For write operations, set REDDIT_USERNAME and REDDIT_PASSWORD");
+		}
+		if (safeModeConfig.enabled) {
+			console.error(`[Setup] ✓ Safe mode enabled: ${safeModeConfig.mode}`);
+			console.error(`[Setup]   - Write delay: ${safeModeConfig.writeDelayMs}ms between operations`);
+			console.error(`[Setup]   - Duplicate detection: enabled (tracking last ${safeModeConfig.maxRecentHashes} items)`);
+		} else {
+			console.error("[Setup] Safe mode: off (no write operation safeguards)");
+			console.error("[Setup] Consider enabling REDDIT_SAFE_MODE=standard for spam protection");
+		}
+	} catch (error) {
+		console.error("[Error] ✗ 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.
-  
+const server = new fastmcp.FastMCP({
+	name: "reddit-mcp-server",
+	version: "1.2.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.`,
-  // 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 };
-    }
-  }
+For write operations (posting, replying, editing, deleting), ensure REDDIT_USERNAME and REDDIT_PASSWORD are configured.`,
+	...process.env.OAUTH_ENABLED === "true" && { authenticate: async (request) => {
+		const authHeader = request.headers.authorization;
+		const expectedToken = process.env.OAUTH_TOKEN;
+		if (!expectedToken) {
+			const token = Array.from({ length: 32 }, () => "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".charAt(Math.floor(Math.random() * 62))).join("");
+			console.log(`[Auth] Generated OAuth token: ${token}`);
+			throw new Response(JSON.stringify({
+				error: "No OAuth token configured",
+				generatedToken: token
+			}), {
+				status: 401,
+				headers: { "Content-Type": "application/json" }
+			});
+		}
+		if (!(authHeader === null || authHeader === void 0 ? void 0 : authHeader.startsWith("Bearer "))) throw new Response(null, {
+			status: 401,
+			statusText: "Missing or invalid Authorization header"
+		});
+		if (authHeader.slice(7) !== 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
+	name: "test_reddit_mcp_server",
+	description: "Test the Reddit MCP Server connection and configuration",
+	parameters: zod.z.object({}),
+	execute: async () => {
+		const client = getRedditClient();
+		const hasAuth = client ? "✓" : "✗";
+		const hasWriteAccess = process.env.REDDIT_USERNAME && process.env.REDDIT_PASSWORD ? "✓" : "✗";
+		return `Reddit MCP Server Status:
+- Server: ✓ Running
 - Reddit Client: ${hasAuth} ${client ? "Initialized" : "Not initialized"}  
-- Write Access: ${hasWriteAccess} ${hasWriteAccess === "\u2713" ? "Available" : "Read-only mode"}
-- Version: 1.1.0
+- Write Access: ${hasWriteAccess} ${hasWriteAccess === "✓" ? "Available" : "Read-only mode"}
+- Version: 1.2.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 `# User Information: u/${formattedUser.username}
+	name: "get_user_info",
+	description: "Get detailed information about a Reddit user including karma, account status, and activity analysis",
+	parameters: zod.z.object({ username: 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 formattedUser = formatUserInfo(await client.getUser(args.username));
+		return `# User Information: u/${formattedUser.username}
 
 ## Profile Overview
 - Username: u/${formattedUser.username}
@@ -867,98 +995,109 @@ server.addTool({
 
 ## Recommendations
 - ${formattedUser.recommendations.replace(/\n {2}- /g, "\n- ")}`;
-  }
+	}
 });
 server.addTool({
-  name: "get_user_posts",
-  description: "Get recent posts by a Reddit user with sorting and filtering options",
-  parameters: import_zod.z.object({
-    username: import_zod.z.string().describe("The Reddit username (without u/ prefix)"),
-    sort: import_zod.z.enum(["new", "hot", "top"]).default("new").describe("Sort order for posts"),
-    time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("all").describe("Time filter for top posts"),
-    limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of posts to retrieve")
-  }),
-  execute: async (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
-    });
-    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(" ")}
+	name: "get_user_posts",
+	description: "Get recent posts by a Reddit user with sorting and filtering options",
+	parameters: zod.z.object({
+		username: zod.z.string().describe("The Reddit username (without u/ prefix)"),
+		sort: zod.z.enum([
+			"new",
+			"hot",
+			"top"
+		]).default("new").describe("Sort order for posts"),
+		time_filter: zod.z.enum([
+			"hour",
+			"day",
+			"week",
+			"month",
+			"year",
+			"all"
+		]).default("all").describe("Time filter for top posts"),
+		limit: 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
+		});
+		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.toLocaleString()} (${(post.upvoteRatio * 100).toFixed(1)}% upvoted)
 - Comments: ${post.numComments.toLocaleString()}
-- Posted: ${new Date(post.createdUtc * 1e3).toLocaleString()}
+- Posted: ${(/* @__PURE__ */ 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})
+		}).join("\n\n");
+		return `# Posts by u/${args.username} (${args.sort} - ${args.time_filter})
 
 ${postSummaries}`;
-  }
+	}
 });
 server.addTool({
-  name: "get_user_comments",
-  description: "Get recent comments by a Reddit user with sorting and filtering options",
-  parameters: import_zod.z.object({
-    username: import_zod.z.string().describe("The Reddit username (without u/ prefix)"),
-    sort: import_zod.z.enum(["new", "hot", "top"]).default("new").describe("Sort order for comments"),
-    time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("all").describe("Time filter for top comments"),
-    limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of comments to retrieve")
-  }),
-  execute: async (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
-    });
-    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(" ")}
+	name: "get_user_comments",
+	description: "Get recent comments by a Reddit user with sorting and filtering options",
+	parameters: zod.z.object({
+		username: zod.z.string().describe("The Reddit username (without u/ prefix)"),
+		sort: zod.z.enum([
+			"new",
+			"hot",
+			"top"
+		]).default("new").describe("Sort order for comments"),
+		time_filter: zod.z.enum([
+			"hour",
+			"day",
+			"week",
+			"month",
+			"year",
+			"all"
+		]).default("all").describe("Time filter for top comments"),
+		limit: 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
+		});
+		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}"
 
 > ${truncatedBody}
 
 - Score: ${comment.score.toLocaleString()}
-- Posted: ${new Date(comment.createdUtc * 1e3).toLocaleString()}
+- Posted: ${(/* @__PURE__ */ 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})
+		}).join("\n\n");
+		return `# Comments by u/${args.username} (${args.sort} - ${args.time_filter})
 
 ${commentSummaries}`;
-  }
+	}
 });
 server.addTool({
-  name: "get_reddit_post",
-  description: "Get detailed information about a specific Reddit post including content, stats, and engagement analysis",
-  parameters: import_zod.z.object({
-    subreddit: import_zod.z.string().describe("The subreddit name (without r/ prefix)"),
-    post_id: import_zod.z.string().describe("The Reddit post ID")
-  }),
-  execute: async (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 `# Post from r/${formattedPost.subreddit}
+	name: "get_reddit_post",
+	description: "Get detailed information about a specific Reddit post including content, stats, and engagement analysis",
+	parameters: zod.z.object({
+		subreddit: zod.z.string().describe("The subreddit name (without r/ prefix)"),
+		post_id: zod.z.string().describe("The Reddit post ID")
+	}),
+	execute: async (args) => {
+		const client = getRedditClient();
+		if (!client) throw new Error("Reddit client not initialized");
+		const formattedPost = formatPostInfo(await client.getPost(args.post_id, args.subreddit));
+		return `# Post from r/${formattedPost.subreddit}
 
 ## Post Details
 - Title: ${formattedPost.title}
@@ -987,55 +1126,48 @@ ${formattedPost.content}
 
 ## Best Time to Engage
 ${formattedPost.bestTimeToEngage}`;
-  }
+	}
 });
 server.addTool({
-  name: "get_top_posts",
-  description: "Get top posts from a subreddit or from the Reddit home feed",
-  parameters: import_zod.z.object({
-    subreddit: import_zod.z.string().optional().describe("The subreddit name (without r/ prefix). Leave empty for home feed"),
-    time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("week").describe("Time period for top posts"),
-    limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of posts to retrieve")
-  }),
-  execute: async (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}
+	name: "get_top_posts",
+	description: "Get top posts from a subreddit or from the Reddit home feed",
+	parameters: zod.z.object({
+		subreddit: zod.z.string().optional().describe("The subreddit name (without r/ prefix). Leave empty for home feed"),
+		time_filter: zod.z.enum([
+			"hour",
+			"day",
+			"week",
+			"month",
+			"year",
+			"all"
+		]).default("week").describe("Time period for top posts"),
+		limit: 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) return `No posts found in ${args.subreddit ? `r/${args.subreddit}` : "home feed"} for the specified time period.`;
+		const postSummaries = posts.map(formatPostInfo).map((post, index) => `### ${index + 1}. ${post.title}
 - Author: u/${post.author}
 - Score: ${post.stats.score.toLocaleString()} (${(post.stats.upvoteRatio * 100).toFixed(1)}% upvoted)
 - Comments: ${post.stats.comments.toLocaleString()}
 - Posted: ${post.metadata.posted}
-- Link: ${post.links.shortLink}`
-    ).join("\n\n");
-    const location = args.subreddit ? `r/${args.subreddit}` : "Home Feed";
-    return `# Top Posts from ${location} (${args.time_filter})
+- Link: ${post.links.shortLink}`).join("\n\n");
+		return `# Top Posts from ${args.subreddit ? `r/${args.subreddit}` : "Home Feed"} (${args.time_filter})
 
 ${postSummaries}`;
-  }
+	}
 });
 server.addTool({
-  name: "get_subreddit_info",
-  description: "Get detailed information about a subreddit including description, stats, and community analysis",
-  parameters: import_zod.z.object({
-    subreddit_name: import_zod.z.string().describe("The subreddit name (without r/ prefix)")
-  }),
-  execute: async (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 `# Subreddit Information: r/${formattedSubreddit.name}
+	name: "get_subreddit_info",
+	description: "Get detailed information about a subreddit including description, stats, and community analysis",
+	parameters: zod.z.object({ subreddit_name: 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 formattedSubreddit = formatSubredditInfo(await client.getSubredditInfo(args.subreddit_name));
+		return `# Subreddit Information: r/${formattedSubreddit.name}
 
 ## Overview
 - Name: r/${formattedSubreddit.name}
@@ -1062,138 +1194,291 @@ ${formattedSubreddit.description.full}
 
 ## Engagement Tips
 - ${formattedSubreddit.engagementTips.replace(/\n  - /g, "\n- ")}`;
-  }
+	}
 });
 server.addTool({
-  name: "get_trending_subreddits",
-  description: "Get a list of currently trending subreddits",
-  parameters: import_zod.z.object({}),
-  execute: async () => {
-    const client = getRedditClient();
-    if (!client) {
-      throw new Error("Reddit client not initialized");
-    }
-    const trendingSubreddits = await client.getTrendingSubreddits();
-    return `# Trending Subreddits
+	name: "get_trending_subreddits",
+	description: "Get a list of currently trending subreddits",
+	parameters: zod.z.object({}),
+	execute: async () => {
+		const client = getRedditClient();
+		if (!client) throw new Error("Reddit client not initialized");
+		return `# Trending Subreddits
 
-${trendingSubreddits.map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}`;
-  }
+${(await client.getTrendingSubreddits()).map((subreddit, index) => `${index + 1}. r/${subreddit}`).join("\n")}`;
+	}
 });
 server.addTool({
-  name: "search_reddit",
-  description: "Search Reddit for posts and content across subreddits",
-  parameters: import_zod.z.object({
-    query: import_zod.z.string().describe("Search query"),
-    subreddit: import_zod.z.string().optional().describe("Limit search to specific subreddit (without r/ prefix)"),
-    sort: import_zod.z.enum(["relevance", "hot", "top", "new", "comments"]).default("relevance").describe("Sort order"),
-    time_filter: import_zod.z.enum(["hour", "day", "week", "month", "year", "all"]).default("all").describe("Time filter"),
-    limit: import_zod.z.number().min(1).max(100).default(10).describe("Number of results"),
-    type: import_zod.z.enum(["link", "sr", "user"]).default("link").describe("Type of content to search")
-  }),
-  execute: async (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
-    });
-    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(" ")}
+	name: "search_reddit",
+	description: "Search Reddit for posts and content across subreddits",
+	parameters: zod.z.object({
+		query: zod.z.string().describe("Search query"),
+		subreddit: zod.z.string().optional().describe("Limit search to specific subreddit (without r/ prefix)"),
+		sort: zod.z.enum([
+			"relevance",
+			"hot",
+			"top",
+			"new",
+			"comments"
+		]).default("relevance").describe("Sort order"),
+		time_filter: zod.z.enum([
+			"hour",
+			"day",
+			"week",
+			"month",
+			"year",
+			"all"
+		]).default("all").describe("Time filter"),
+		limit: zod.z.number().min(1).max(100).default(10).describe("Number of results"),
+		type: 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
+		});
+		if (posts.length === 0) {
+			const searchLocation$1 = args.subreddit ? ` in r/${args.subreddit}` : "";
+			return `No results found for "${args.query}"${searchLocation$1}.`;
+		}
+		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()}
+- Posted: ${(/* @__PURE__ */ 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}
+		}).join("\n\n");
+		const searchLocation = args.subreddit ? ` in r/${args.subreddit}` : "";
+		return `# Reddit Search Results for: "${args.query}"${searchLocation}
 
 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). WARNING: Rapid posting or duplicate content may trigger Reddit's spam detection and result in account bans. Consider enabling REDDIT_SAFE_MODE=standard for protection.",
+	parameters: zod.z.object({
+		subreddit: zod.z.string().describe("The subreddit name (without r/ prefix)"),
+		title: zod.z.string().describe("The post title"),
+		content: zod.z.string().describe("The post content (text for self posts, URL for link posts)"),
+		is_self: 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 formattedPost = formatPostInfo(await client.createPost(args.subreddit, args.title, args.content, args.is_self));
+		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). WARNING: Rapid commenting or duplicate content may trigger Reddit's spam detection. Enable REDDIT_SAFE_MODE=standard for rate limiting and duplicate detection.",
+	parameters: zod.z.object({
+		post_id: zod.z.string().describe("The Reddit post ID (thing_id, e.g., t3_xxxxx for posts, t1_xxxxx for comments)"),
+		content: 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: "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}
+	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: zod.z.object({ thing_id: 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: zod.z.object({ thing_id: 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. WARNING: Rapid edits may trigger spam detection. Enable REDDIT_SAFE_MODE for protection.",
+	parameters: zod.z.object({
+		thing_id: 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: 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. WARNING: Rapid edits may trigger spam detection. Enable REDDIT_SAFE_MODE for protection.",
+	parameters: zod.z.object({
+		thing_id: 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: 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",
+	parameters: zod.z.object({
+		post_id: zod.z.string().describe("The Reddit post ID"),
+		subreddit: zod.z.string().describe("The subreddit name (without r/ prefix)"),
+		sort: zod.z.enum([
+			"best",
+			"top",
+			"new",
+			"controversial",
+			"old",
+			"qa"
+		]).default("best").describe("Comment sort order"),
+		limit: 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()}
+- Posted: ${(/* @__PURE__ */ 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)
+		if (comments.length === 0) {
+			response += "No comments found for this post.";
+			return response;
+		}
+		const commentSummaries = comments.map((comment) => {
+			const indent = "└─".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;
-  }
+		}).join("\n\n");
+		response += commentSummaries;
+		return response;
+	}
 });
 async function main() {
-  try {
-    await setupRedditClient();
-    await server.start({
-      transportType: "stdio"
-    });
-  } catch (error) {
-    console.error("[Error] Failed to start server:", error);
-    process.exit(1);
-  }
+	try {
+		await setupRedditClient();
+		const useHttp = process.env.TRANSPORT_TYPE === "httpStream" || process.env.TRANSPORT_TYPE === "http";
+		const port = parseInt(process.env.PORT || "3000");
+		const host = process.env.HOST || "0.0.0.0";
+		if (useHttp) {
+			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`);
+		} else {
+			console.error("[Setup] Starting in stdio mode");
+			await server.start({ transportType: "stdio" });
+		}
+	} 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);
+	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);
+	console.error("[Shutdown] Shutting down Reddit MCP Server...");
+	process.exit(0);
 });
 main().catch(console.error);
+
+//#endregion
+//# sourceMappingURL=index.js.map