@mcpware/reddit-unofficial-api 0.1.0

package/README.md

@@ -0,0 +1,178 @@
+# Reddit Unofficial API — MCP Server
+
+Free Reddit API. No API keys, no OAuth registration, no monthly fees.
+
+All you need is Chrome with Reddit logged in, and Chrome DevTools Protocol enabled.
+
+## How it works
+
+This MCP server talks to Reddit through your browser session. When you're logged into Reddit in Chrome, your browser already has all the authentication it needs. This server simply executes `fetch()` calls in your Reddit tab's context, using the same cookies your browser uses.
+
+```
+AI Assistant → this MCP server → Chrome DevTools Protocol → your Reddit tab → Reddit's internal API
+```
+
+Reddit's internal API (the same endpoints their website uses) gives you everything: read posts, write comments, vote, search, send messages, manage subscriptions. All free, all through your existing session.
+
+## Setup
+
+### 1. Start Chrome with DevTools Protocol enabled
+
+```bash
+# macOS
+/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222
+
+# Linux
+google-chrome --remote-debugging-port=9222
+
+# Windows
+"C:\Program Files\Google\Chrome\Application\chrome.exe" --remote-debugging-port=9222
+```
+
+### 2. Log into Reddit in Chrome
+
+Just open reddit.com and log in normally.
+
+### 3. Add to your MCP config
+
+```json
+{
+  "mcpServers": {
+    "reddit": {
+      "command": "npx",
+      "args": ["-y", "@mcpware/reddit-unofficial-api"]
+    }
+  }
+}
+```
+
+If Chrome is on a non-default host/port:
+
+```json
+{
+  "mcpServers": {
+    "reddit": {
+      "command": "npx",
+      "args": ["-y", "@mcpware/reddit-unofficial-api"],
+      "env": {
+        "CHROME_CDP_HOST": "localhost",
+        "CHROME_CDP_PORT": "9222"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Read (no rate limit concerns)
+
+| Tool | What it does |
+|------|-------------|
+| `reddit_me` | Who am I? Get your user info |
+| `reddit_get_post` | Get a post and its comments |
+| `reddit_get_comments` | Get all comments as a flat list (great for analysis) |
+| `reddit_get_user` | Look up any user's profile, posts, or comments |
+| `reddit_get_subreddit` | Get subreddit info, rules, or browse posts |
+| `reddit_search` | Search across Reddit or within a subreddit |
+| `reddit_get_inbox` | Read your messages |
+| `reddit_get_subscriptions` | List your subscribed subreddits |
+
+### Write (1.5s rate limit between calls)
+
+| Tool | What it does |
+|------|-------------|
+| `reddit_comment` | Reply to any post or comment |
+| `reddit_submit` | Create a new post (text or link) |
+| `reddit_vote` | Upvote, downvote, or unvote |
+| `reddit_save` | Save/unsave posts or comments |
+| `reddit_send_message` | Send a private message |
+| `reddit_edit` | Edit your own content |
+| `reddit_delete` | Delete your own content |
+| `reddit_subscribe` | Join or leave a subreddit |
+
+### Utility
+
+| Tool | What it does |
+|------|-------------|
+| `reddit_ensure_session` | Verify everything is connected and you're logged in |
+
+## What can you do with this?
+
+### Community Management
+- **Monitor your posts**: "check my PokeClaw post for new comments that need replies" → scrapes all comments, categorizes them (bug report, question, feature request, positive feedback), drafts replies, you approve, it posts
+- **Batch reply**: reply to 10+ comments in one go with personalized responses, auto-verified to make sure each reply goes to the right person
+- **Update your posts**: edit the body of an existing post to add changelogs, new links, or corrections
+
+### Research & Competitive Intelligence
+- **Search Reddit**: find all posts mentioning your product, a competitor, or a topic across any subreddit
+- **User research**: look up anyone's post history, comment history, karma breakdown
+- **Subreddit discovery**: find relevant subreddits for your niche, check their rules before posting
+
+### Content & Marketing
+- **Cross-post to multiple subreddits**: draft a post, you approve, submit to r/LocalLLaMA, r/androiddev, r/machinelearning, etc.
+- **Track engagement**: check which of your posts/comments are getting upvoted or replied to
+- **Save interesting threads**: bookmark posts and comments for later reference
+
+### Inbox & Messaging
+- **Read DMs**: check if anyone messaged you about your project
+- **Send DMs**: reach out to users who want to contribute or reported bugs
+- **Mark as read**: clean up your inbox
+
+### Engagement
+- **Upvote helpful feedback**: upvote users who gave useful bug reports or feature suggestions
+- **Subscribe to subreddits**: join relevant communities from your AI assistant
+
+### Deep Research
+- **Topic deep-dive**: "research what Reddit thinks about on-device LLM apps" → searches multiple subreddits, reads top posts and comment threads, summarizes sentiment, common complaints, feature requests, and what users actually want
+- **Competitor analysis**: "what are people saying about DroidRun vs OpenClaw" → finds all relevant threads, extracts comparisons, user experiences, pros/cons mentioned
+- **Market validation**: "is there demand for WhatsApp auto-reply bots" → searches across subreddits, analyzes upvotes and engagement, identifies the audience and their pain points
+- **Trend tracking**: "what local LLM topics are trending this week on r/LocalLLaMA" → fetches top/rising posts, identifies emerging themes
+
+Everything runs through your existing browser session. Zero cost, no API keys, no rate limit surprises.
+
+## Why not just use the official Reddit API?
+
+Reddit killed free API access in 2023. The official API now requires app registration, OAuth flows, and has strict rate limits. If you're building something for personal use with your own account, jumping through those hoops makes no sense.
+
+This approach uses the exact same endpoints Reddit's own website uses. Your browser is already authenticated. We just let your AI assistant use that same session.
+
+## Safety Guidelines — Don't Get Your Account Banned
+
+This tool uses your real Reddit account. Reddit can't tell the difference between you typing and this tool typing, because it's the same browser session. That's the whole point. But it also means you need to behave like a human.
+
+**Why the risk is low:**
+- Requests come from your normal browser with your normal cookies. To Reddit's servers, it looks identical to you clicking buttons manually.
+- The server adds delays between write operations (1.5s minimum). You're not hammering their API.
+- Content is genuine (you write and approve the replies), not auto-generated spam.
+
+**Rules to follow:**
+- **Don't batch reply too aggressively.** 10-15 replies in one session is fine. 50 replies in 10 minutes is not. Spread it out across a few hours if you have a lot to respond to.
+- **Vary your reply content.** If every reply has the exact same structure, links, and call-to-action, Reddit's spam filter will notice. Make each reply address the specific person's point.
+- **Mix in normal behavior.** Browse, upvote a few things, read some posts. Don't make your entire session activity look like a bot replying to everything.
+- **Don't use this for spam, vote manipulation, or astroturfing.** Obviously. This is for managing your own community and doing research, not gaming Reddit.
+- **Respect subreddit rules.** Some subs don't allow self-promotion. Check before cross-posting.
+
+**What happens if Reddit flags you:**
+- Most likely: temporary rate limit (can't post for a few hours)
+- Less likely: shadowban (your replies only visible to you, check at r/ShadowBan)
+- Very unlikely: account suspension (only for obvious spam or manipulation)
+
+**Recovery:**
+- If rate limited, just wait. It resets.
+- If shadowbanned, appeal at reddit.com/appeal. Usually reversed if your content is genuine.
+- Best prevention: keep it natural. If a human wouldn't post 30 comments in 5 minutes, don't do it with this tool either.
+
+## Limitations
+
+- Needs Chrome running with DevTools Protocol (port 9222)
+- Needs you to be logged into Reddit in that Chrome instance
+- One Reddit account at a time (whichever is logged in)
+- Rate limits are undocumented but generous for normal use
+- Not suitable for high-volume scraping or bot armies (and you shouldn't do that anyway)
+
+## Install from npm
+
+```bash
+npm install -g @mcpware/reddit-unofficial-api
+```

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,525 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import CDP from "chrome-remote-interface";
+// Reddit Unofficial API — MCP Server
+// Executes fetch() in Chrome's Reddit tab context via CDP
+// Requires: Chrome with --remote-debugging-port=9222 + Reddit tab logged in
+const server = new McpServer({
+    name: "reddit-unofficial-api",
+    version: "0.1.0",
+});
+// ==================== Configuration ====================
+const CDP_HOST = process.env.CHROME_CDP_HOST || "localhost";
+const CDP_PORT = parseInt(process.env.CHROME_CDP_PORT || "9222", 10);
+const RATE_LIMIT_MS = 1500;
+let lastWriteTime = 0;
+async function rateLimit() {
+    const now = Date.now();
+    const elapsed = now - lastWriteTime;
+    if (elapsed < RATE_LIMIT_MS) {
+        await new Promise((r) => setTimeout(r, RATE_LIMIT_MS - elapsed));
+    }
+    lastWriteTime = Date.now();
+}
+// ==================== CDP Connection ====================
+let cachedClient = null;
+let cachedTargetId = null;
+async function findRedditTarget() {
+    let targets;
+    try {
+        targets = await CDP.List({ host: CDP_HOST, port: CDP_PORT });
+    }
+    catch (e) {
+        throw new Error(`Cannot connect to Chrome DevTools at ${CDP_HOST}:${CDP_PORT}. ` +
+            `Start Chrome with: google-chrome --remote-debugging-port=${CDP_PORT}`);
+    }
+    const redditTab = targets.find((t) => t.type === "page" && t.url?.includes("reddit.com"));
+    if (!redditTab) {
+        throw new Error("No Reddit tab found in Chrome. Open reddit.com and log in first.");
+    }
+    return redditTab;
+}
+async function getClient() {
+    // Reuse connection if target hasn't changed
+    if (cachedClient && cachedTargetId) {
+        try {
+            // Quick health check — if the tab closed, this will fail
+            await cachedClient.Runtime.evaluate({ expression: "1" });
+            return cachedClient;
+        }
+        catch {
+            // Connection stale, reconnect
+            try {
+                await cachedClient.close();
+            }
+            catch {
+                /* already dead */
+            }
+            cachedClient = null;
+            cachedTargetId = null;
+        }
+    }
+    const target = await findRedditTarget();
+    const client = await CDP({ host: CDP_HOST, port: CDP_PORT, target });
+    await client.Runtime.enable();
+    cachedClient = client;
+    cachedTargetId = target.id;
+    return client;
+}
+async function evalInReddit(script) {
+    const client = await getClient();
+    const result = await client.Runtime.evaluate({
+        expression: script,
+        awaitPromise: true,
+        returnByValue: true,
+    });
+    if (result.exceptionDetails) {
+        const msg = result.exceptionDetails.text ||
+            result.result?.description ||
+            "Unknown eval error";
+        throw new Error(`Reddit eval error: ${msg}`);
+    }
+    return result.result?.value;
+}
+// ==================== Reddit API Helpers ====================
+async function getModhash() {
+    const result = await evalInReddit(`
+    (async () => {
+      const resp = await fetch('https://www.reddit.com/api/me.json', { credentials: 'include' });
+      const data = await resp.json();
+      return data.data?.modhash || '';
+    })()
+  `);
+    if (!result) {
+        throw new Error("Could not get modhash — you may not be logged in to Reddit. " +
+            "Open reddit.com in Chrome and log in.");
+    }
+    return result;
+}
+async function redditGet(path, params = {}) {
+    const qs = new URLSearchParams(params).toString();
+    const url = `https://www.reddit.com${path}${qs ? "?" + qs : ""}`;
+    const result = await evalInReddit(`
+    (async () => {
+      const resp = await fetch('${url}', { credentials: 'include' });
+      if (resp.status === 429) return { error: 'rate_limited', status: 429 };
+      if (!resp.ok) return { error: resp.status, statusText: resp.statusText };
+      return await resp.json();
+    })()
+  `);
+    if (result?.error === "rate_limited") {
+        throw new Error("Reddit rate limited this request. Wait a few minutes and try again.");
+    }
+    if (result?.error && typeof result.error === "number") {
+        throw new Error(`Reddit API returned HTTP ${result.error}: ${result.statusText}`);
+    }
+    return result;
+}
+async function redditPost(path, params) {
+    await rateLimit();
+    const modhash = await getModhash();
+    params.uh = modhash;
+    params.api_type = "json";
+    const body = new URLSearchParams(params).toString();
+    const result = await evalInReddit(`
+    (async () => {
+      const resp = await fetch('https://www.reddit.com${path}', {
+        method: 'POST',
+        credentials: 'include',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: '${body.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'
+      });
+      if (resp.status === 429) return { json: { errors: [['RATELIMIT', 'Rate limited by Reddit. Wait a few minutes.']] } };
+      const text = await resp.text();
+      try { return JSON.parse(text); } catch(e) { return { error: 'parse_error', raw: text.substring(0, 500) }; }
+    })()
+  `);
+    // Check for Reddit API errors
+    if (result?.json?.errors?.length) {
+        const errors = result.json.errors.map((e) => (Array.isArray(e) ? e.join(": ") : e));
+        throw new Error(`Reddit API error: ${errors.join("; ")}`);
+    }
+    return result;
+}
+function wrapTool(handler) {
+    return async (args) => {
+        try {
+            return await handler(args);
+        }
+        catch (e) {
+            const msg = e.message || String(e);
+            console.error(`[reddit-mcp] Error: ${msg}`);
+            return {
+                content: [{ type: "text", text: `Error: ${msg}` }],
+                isError: true,
+            };
+        }
+    };
+}
+// ==================== MCP Tools — Read Operations ====================
+server.tool("reddit_ensure_session", "Check if Chrome is running, Reddit tab exists, and user is logged in. Call this first.", {}, wrapTool(async () => {
+    const data = await redditGet("/api/me.json");
+    const username = data.data?.name;
+    if (username) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Connected. Logged in as u/${username}. Reddit API ready.`,
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: "Reddit tab found but not logged in. Please log in to Reddit in Chrome first.",
+            },
+        ],
+    };
+}));
+server.tool("reddit_me", "Get current logged-in Reddit user info (karma, username, account age, etc.)", {}, wrapTool(async () => {
+    const data = await redditGet("/api/me.json");
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(data.data || data, null, 2) },
+        ],
+    };
+}));
+server.tool("reddit_get_post", "Get a Reddit post and its comments by URL or post ID", {
+    url: z
+        .string()
+        .describe("Reddit post URL or post ID (e.g. '1sdv3lo')"),
+    sort: z
+        .enum(["top", "new", "best", "controversial", "old", "qa"])
+        .default("top")
+        .describe("Comment sort order"),
+    limit: z.number().default(100).describe("Max comments to return"),
+}, wrapTool(async ({ url, sort, limit }) => {
+    const match = url.match(/comments\/([a-z0-9]+)/);
+    const postId = match ? match[1] : url;
+    const data = await redditGet(`/comments/${postId}.json`, {
+        sort,
+        limit: String(limit),
+    });
+    if (Array.isArray(data) && data.length >= 2) {
+        const post = data[0]?.data?.children?.[0]?.data;
+        const comments = data[1]?.data?.children?.map((c) => c.data) || [];
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ post, comments }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    };
+}));
+server.tool("reddit_get_comments", "Get all comments for a post as a flat list with author, body, score, and parent info", {
+    url: z.string().describe("Reddit post URL or post ID"),
+    sort: z
+        .enum(["top", "new", "best", "controversial", "old", "qa"])
+        .default("top"),
+}, wrapTool(async ({ url, sort }) => {
+    const match = url.match(/comments\/([a-z0-9]+)/);
+    const postId = match ? match[1] : url;
+    const data = await redditGet(`/comments/${postId}.json`, {
+        sort,
+        limit: "500",
+    });
+    if (!Array.isArray(data) || data.length < 2) {
+        return {
+            content: [{ type: "text", text: "Could not fetch comments" }],
+        };
+    }
+    const flat = [];
+    function extract(children, depth = 0) {
+        for (const child of children) {
+            if (child.kind !== "t1")
+                continue;
+            const c = child.data;
+            flat.push({
+                id: c.name,
+                author: c.author,
+                body: c.body,
+                score: c.score,
+                parent_id: c.parent_id,
+                depth,
+                created_utc: c.created_utc,
+            });
+            if (c.replies?.data?.children) {
+                extract(c.replies.data.children, depth + 1);
+            }
+        }
+    }
+    extract(data[1].data.children);
+    return {
+        content: [{ type: "text", text: JSON.stringify(flat, null, 2) }],
+    };
+}));
+server.tool("reddit_get_user", "Get a Reddit user's profile, posts, or comments", {
+    username: z.string().describe("Reddit username"),
+    type: z
+        .enum(["about", "overview", "submitted", "comments"])
+        .default("about"),
+    limit: z.number().default(25),
+}, wrapTool(async ({ username, type, limit }) => {
+    const path = type === "about"
+        ? `/user/${username}/about.json`
+        : `/user/${username}/${type}.json`;
+    const data = await redditGet(path, { limit: String(limit) });
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(data.data || data, null, 2) },
+        ],
+    };
+}));
+server.tool("reddit_get_subreddit", "Get subreddit info, rules, or browse posts (hot/new/top/rising)", {
+    subreddit: z.string().describe("Subreddit name (without r/)"),
+    type: z
+        .enum(["about", "rules", "hot", "new", "top", "rising"])
+        .default("hot"),
+    limit: z.number().default(25),
+    time: z
+        .enum(["hour", "day", "week", "month", "year", "all"])
+        .default("day")
+        .describe("Time filter for top/controversial"),
+}, wrapTool(async ({ subreddit, type, limit, time }) => {
+    const path = ["about", "rules"].includes(type)
+        ? `/r/${subreddit}/about/${type === "about" ? "" : "rules"}.json`
+        : `/r/${subreddit}/${type}.json`;
+    const data = await redditGet(path, { limit: String(limit), t: time });
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(data.data || data, null, 2) },
+        ],
+    };
+}));
+server.tool("reddit_search", "Search Reddit posts globally or within a specific subreddit", {
+    query: z.string().describe("Search query"),
+    subreddit: z
+        .string()
+        .optional()
+        .describe("Limit search to this subreddit (optional)"),
+    sort: z
+        .enum(["relevance", "hot", "top", "new", "comments"])
+        .default("relevance"),
+    time: z
+        .enum(["hour", "day", "week", "month", "year", "all"])
+        .default("all"),
+    limit: z.number().default(25),
+}, wrapTool(async ({ query, subreddit, sort, time, limit }) => {
+    const path = subreddit ? `/r/${subreddit}/search.json` : `/search.json`;
+    const params = {
+        q: query,
+        sort,
+        t: time,
+        limit: String(limit),
+    };
+    if (subreddit)
+        params.restrict_sr = "on";
+    const data = await redditGet(path, params);
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(data.data || data, null, 2) },
+        ],
+    };
+}));
+server.tool("reddit_get_inbox", "Get Reddit messages (inbox, unread, or sent)", {
+    type: z.enum(["inbox", "unread", "sent"]).default("unread"),
+    limit: z.number().default(25),
+}, wrapTool(async ({ type, limit }) => {
+    const data = await redditGet(`/message/${type}.json`, {
+        limit: String(limit),
+    });
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(data.data || data, null, 2) },
+        ],
+    };
+}));
+server.tool("reddit_get_subscriptions", "Get your subscribed subreddits", {
+    limit: z.number().default(100).describe("Max subreddits to return"),
+}, wrapTool(async ({ limit }) => {
+    const data = await redditGet("/subreddits/mine/subscriber.json", {
+        limit: String(limit),
+    });
+    const subs = data.data?.children?.map((c) => ({
+        name: c.data.display_name,
+        title: c.data.title,
+        subscribers: c.data.subscribers,
+        url: c.data.url,
+    })) || [];
+    return {
+        content: [{ type: "text", text: JSON.stringify(subs, null, 2) }],
+    };
+}));
+// ==================== MCP Tools — Write Operations ====================
+server.tool("reddit_comment", "Reply to a Reddit post or comment. thing_id must start with t1_ (comment) or t3_ (post).", {
+    thing_id: z
+        .string()
+        .describe("Fullname of parent (t1_ for comment, t3_ for post)"),
+    text: z.string().describe("Comment text (markdown supported)"),
+}, wrapTool(async ({ thing_id, text }) => {
+    const result = await redditPost("/api/comment", { thing_id, text });
+    const commentData = result.json?.data?.things?.[0]?.data;
+    const commentId = commentData?.id || commentData?.name;
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    comment_id: commentId,
+                }),
+            },
+        ],
+    };
+}));
+server.tool("reddit_submit", "Create a new Reddit post (text or link)", {
+    subreddit: z.string().describe("Subreddit name (without r/)"),
+    title: z.string().describe("Post title"),
+    kind: z.enum(["self", "link"]).describe("Post type: self (text) or link"),
+    text: z.string().optional().describe("Post body text (for self posts)"),
+    url: z.string().optional().describe("URL (for link posts)"),
+    flair_id: z.string().optional().describe("Flair template ID"),
+    flair_text: z.string().optional().describe("Flair text"),
+    nsfw: z.boolean().default(false),
+    spoiler: z.boolean().default(false),
+}, wrapTool(async ({ subreddit, title, kind, text, url, flair_id, flair_text, nsfw, spoiler, }) => {
+    const params = { sr: subreddit, title, kind };
+    if (text)
+        params.text = text;
+    if (url)
+        params.url = url;
+    if (flair_id)
+        params.flair_id = flair_id;
+    if (flair_text)
+        params.flair_text = flair_text;
+    if (nsfw)
+        params.nsfw = "true";
+    if (spoiler)
+        params.spoiler = "true";
+    params.sendreplies = "true";
+    params.resubmit = "true";
+    const result = await redditPost("/api/submit", params);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result.json || result, null, 2),
+            },
+        ],
+    };
+}));
+server.tool("reddit_vote", "Upvote, downvote, or unvote on a post or comment", {
+    thing_id: z.string().describe("Fullname (t1_ or t3_)"),
+    direction: z.enum(["up", "down", "unvote"]).describe("Vote direction"),
+}, wrapTool(async ({ thing_id, direction }) => {
+    const dir = direction === "up" ? "1" : direction === "down" ? "-1" : "0";
+    await redditPost("/api/vote", { id: thing_id, dir });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, thing_id, direction }),
+            },
+        ],
+    };
+}));
+server.tool("reddit_save", "Save or unsave a Reddit post or comment", {
+    thing_id: z.string().describe("Fullname (t1_ or t3_)"),
+    unsave: z.boolean().default(false).describe("Set true to unsave"),
+}, wrapTool(async ({ thing_id, unsave }) => {
+    const path = unsave ? "/api/unsave" : "/api/save";
+    await redditPost(path, { id: thing_id });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    success: true,
+                    action: unsave ? "unsaved" : "saved",
+                    thing_id,
+                }),
+            },
+        ],
+    };
+}));
+server.tool("reddit_send_message", "Send a Reddit private message to a user", {
+    to: z.string().describe("Username to send to"),
+    subject: z.string().describe("Message subject"),
+    text: z.string().describe("Message body"),
+}, wrapTool(async ({ to, subject, text }) => {
+    await redditPost("/api/compose", { to, subject, text });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, to, subject }),
+            },
+        ],
+    };
+}));
+server.tool("reddit_edit", "Edit your own post or comment", {
+    thing_id: z
+        .string()
+        .describe("Fullname of your post/comment to edit"),
+    text: z.string().describe("New text content"),
+}, wrapTool(async ({ thing_id, text }) => {
+    await redditPost("/api/editusertext", { thing_id, text });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, edited: thing_id }),
+            },
+        ],
+    };
+}));
+server.tool("reddit_delete", "Delete your own post or comment", {
+    thing_id: z
+        .string()
+        .describe("Fullname of your post/comment to delete"),
+}, wrapTool(async ({ thing_id }) => {
+    await redditPost("/api/del", { id: thing_id });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, deleted: thing_id }),
+            },
+        ],
+    };
+}));
+server.tool("reddit_subscribe", "Subscribe or unsubscribe to a subreddit", {
+    subreddit: z.string().describe("Subreddit name (without r/)"),
+    unsubscribe: z.boolean().default(false),
+}, wrapTool(async ({ subreddit, unsubscribe }) => {
+    const action = unsubscribe ? "unsub" : "sub";
+    await redditPost("/api/subscribe", { action, sr_name: subreddit });
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ success: true, action, subreddit }),
+            },
+        ],
+    };
+}));
+// ==================== Start Server ====================
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("reddit-unofficial-api MCP server running on stdio");
+}
+main().catch((e) => {
+    console.error("Fatal:", e);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@mcpware/reddit-unofficial-api",
+  "version": "0.1.0",
+  "description": "Free Reddit API through Chrome DevTools. No API keys needed, just a logged-in browser.",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "reddit-unofficial-api": "build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mcpware/reddit-unofficial-api.git"
+  },
+  "homepage": "https://github.com/mcpware/reddit-unofficial-api",
+  "bugs": {
+    "url": "https://github.com/mcpware/reddit-unofficial-api/issues"
+  },
+  "author": "mcpware",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "chrome-remote-interface": "^0.34.0"
+  },
+  "devDependencies": {
+    "@types/chrome-remote-interface": "^0.33.0",
+    "@types/node": "^22.15.3",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  },
+  "keywords": [
+    "reddit",
+    "api",
+    "mcp",
+    "chrome-devtools",
+    "cdp",
+    "unofficial",
+    "free",
+    "model-context-protocol"
+  ]
+}