PyPI - threadfox-lite - Versions diffs - 0.1.1__tar.gz → 0.2.0__tar.gz - Mend

threadfox-lite 0.1.1tar.gz → 0.2.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/.claude-plugin/marketplace.json RENAMED Viewed

@@ -12,7 +12,7 @@
       "name": "threadfox-lite",
       "source": "./",
       "description": "Free, read-only Reddit tools: subreddit rules before you post, post status after, and the reddit-rules-first skill.",
-      "version": "0.1.1",
+      "version": "0.2.0",
       "category": "marketing",
       "homepage": "https://threadfox.vip"
     }

threadfox_lite-0.2.0/.claude-plugin/plugin.json ADDED Viewed

@@ -0,0 +1,31 @@
+{
+  "name": "threadfox-lite",
+  "version": "0.2.0",
+  "description": "Free, read-only Reddit tools: find communities where you may post, read their rules, check your account and whether a post stayed up, plus the reddit-rules-first skill.",
+  "author": {
+    "name": "ThreadFox (AMF Indiana)",
+    "email": "support@threadfox.vip",
+    "url": "https://threadfox.vip"
+  },
+  "homepage": "https://threadfox.vip",
+  "repository": "https://github.com/amflimited/threadfox-lite",
+  "license": "MIT",
+  "keywords": [
+    "reddit",
+    "subreddit-rules",
+    "marketing",
+    "mcp",
+    "skills"
+  ],
+  "mcpServers": {
+    "threadfox-lite": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--directory",
+        "${CLAUDE_PLUGIN_ROOT}",
+        "threadfox-lite"
+      ]
+    }
+  }
+}

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/LAUNCHGUIDE.md RENAMED Viewed

@@ -6,12 +6,12 @@ Reddit tools for Claude Code and Codex: rules first, posts that fit, checks that
 ## Description
 ThreadFox gives your AI the Reddit job. Buying on MCP Marketplace gets you the full ThreadFox kit: your Claude Code or Codex reads each community's rules, writes a post that fits that community, publishes it from your own signed-in Chrome (no Reddit API keys, no exported cookies), answers the comments, and records every outcome in a ledger, stopping where a community removed you. It includes a 12-module course, 48 prompts and a one-command install for Windows, Mac and Linux.
-This server (ThreadFox Lite) runs locally and gives every user two free, read-only tools: subreddit_rules and post_status. Your license key opens the full kit: set MCP_LICENSE_KEY, run threadfox_full_kit, or redeem the key at https://threadfox.vip/redeem for your private library.
+This server (ThreadFox Lite) runs locally and gives every user four free, read-only tools: find_communities, subreddit_rules, account_check and post_status. They read through your own signed-in Chrome (Reddit now asks everyone to sign in before it shows anything), using Microsoft's Playwright Extension. Your license key opens the full kit: set MCP_LICENSE_KEY, run threadfox_full_kit, or redeem the key at https://threadfox.vip/redeem for your private library.
 Built from our own run: 978,227 recorded views from two days of posts (Sept 20-21 UTC), with no ad spend. That is our result, not a promise about yours. Made by AMF Indiana; not affiliated with Reddit, OpenAI or Anthropic.
 ## Setup Requirements
-MCP_LICENSE_KEY (optional): your MCP Marketplace license key. The two read-only tools work without it. Requires uv (uvx) and Python 3.10+.
+MCP_LICENSE_KEY (optional): your MCP Marketplace license key. The read-only tools work without it. Requires uv (uvx), Python 3.10+, Node.js and Microsoft's Playwright Extension in the Chrome where you are signed in to Reddit.
 ## Category
 Marketing
@@ -23,7 +23,7 @@ Reddit marketing, Product launches, Community research, Content distribution, So
 - subreddit_rules: rules, size and description of any subreddit, with self-promotion rules flagged
 - post_status: live, removed or deleted, with score and comment count
 - Full kit with a license: publishing from your own Chrome, replies, outcome ledger, 12-module course, 48 prompts
-- No Reddit API keys, no login for the free tools
+- No Reddit API keys; reads run in your own signed-in Chrome and never post
 - Works with Claude Code, Codex and other MCP clients
 ## Getting Started

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: threadfox-lite
-Version: 0.1.1
+Version: 0.2.0
 Summary: Read a subreddit's rules and check whether a Reddit post is still up, from Claude Code, Codex or any MCP client. Free tools from ThreadFox.
 Project-URL: Homepage, https://threadfox.vip
 Project-URL: Source, https://github.com/amflimited/threadfox-lite
@@ -8,19 +8,20 @@ Author-email: "AMF Indiana (ThreadFox)" <support@threadfox.vip>
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.10
-Requires-Dist: httpx>=0.27
 Requires-Dist: mcp<2,>=1.2.0
 Description-Content-Type: text/markdown
 # ThreadFox Lite
-Free, read-only Reddit tools for Claude Code, Codex and any MCP client, plus a `reddit-rules-first` agent skill.
+Free, read-only Reddit tools for Claude Desktop, Claude Code, Codex and any MCP client, plus a `reddit-rules-first` agent skill.
 - `subreddit_rules`: a subreddit's rules, size and description, with the self-promotion rules flagged. Call it before writing a post.
+- `find_communities`: subreddits about a topic ("bakery marketing", "indie games"), each with its self-promotion rules flagged and whether it mentions a promo thread.
+- `account_check`: a Reddit account's age, karma and standing, and whether its recent posts are removed or hidden from search (the practical sign of a spam filter or shadowban).
 - `post_status`: whether a post is still live, removed by moderators or deleted, with score and comments. Check at 1, 6 and 24 hours.
-- `threadfox_full_kit`: how to get the full ThreadFox kit (posting from your own Chrome, replies, an outcome ledger, a 12-module course).
+- `threadfox_full_kit`: what the full ThreadFox kit adds (finding conversations where people ask for what you sell, posting from your own Chrome, replies, an outcome ledger, a 12-module course).
-No login, no posting, no Reddit API keys: each call is one request to Reddit's public JSON with a descriptive user agent.
+**Reads only, through your own signed-in Chrome.** Reddit now sends every signed-out request, including its public JSON, to a login page, so ThreadFox Lite reads the way you do: in your Chrome, signed in as you, one small read at a time. It never posts, votes or changes anything, and needs no Reddit API keys. One-time setup: [Node.js](https://nodejs.org) and Microsoft's [Playwright Extension](https://chromewebstore.google.com/detail/playwright-extension/mmlmfjhmonkocbjadbfplnigmagldckm) in the Chrome where you are signed in to Reddit. The first read asks you to pick a tab in Chrome.
 ## Install

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/README.md RENAMED Viewed

@@ -1,12 +1,14 @@
 # ThreadFox Lite
-Free, read-only Reddit tools for Claude Code, Codex and any MCP client, plus a `reddit-rules-first` agent skill.
+Free, read-only Reddit tools for Claude Desktop, Claude Code, Codex and any MCP client, plus a `reddit-rules-first` agent skill.
 - `subreddit_rules`: a subreddit's rules, size and description, with the self-promotion rules flagged. Call it before writing a post.
+- `find_communities`: subreddits about a topic ("bakery marketing", "indie games"), each with its self-promotion rules flagged and whether it mentions a promo thread.
+- `account_check`: a Reddit account's age, karma and standing, and whether its recent posts are removed or hidden from search (the practical sign of a spam filter or shadowban).
 - `post_status`: whether a post is still live, removed by moderators or deleted, with score and comments. Check at 1, 6 and 24 hours.
-- `threadfox_full_kit`: how to get the full ThreadFox kit (posting from your own Chrome, replies, an outcome ledger, a 12-module course).
+- `threadfox_full_kit`: what the full ThreadFox kit adds (finding conversations where people ask for what you sell, posting from your own Chrome, replies, an outcome ledger, a 12-module course).
-No login, no posting, no Reddit API keys: each call is one request to Reddit's public JSON with a descriptive user agent.
+**Reads only, through your own signed-in Chrome.** Reddit now sends every signed-out request, including its public JSON, to a login page, so ThreadFox Lite reads the way you do: in your Chrome, signed in as you, one small read at a time. It never posts, votes or changes anything, and needs no Reddit API keys. One-time setup: [Node.js](https://nodejs.org) and Microsoft's [Playwright Extension](https://chromewebstore.google.com/detail/playwright-extension/mmlmfjhmonkocbjadbfplnigmagldckm) in the Chrome where you are signed in to Reddit. The first read asks you to pick a tab in Chrome.
 ## Install

threadfox_lite-0.2.0/manifest.json ADDED Viewed

@@ -0,0 +1,75 @@
+{
+  "manifest_version": "0.4",
+  "name": "threadfox-lite",
+  "display_name": "ThreadFox Lite",
+  "version": "0.2.0",
+  "description": "Find subreddits where you may post, read their rules, check your account and whether a post stayed up. Free, read-only.",
+  "long_description": "Free, read-only Reddit tools for Claude and any MCP client. find_communities lists subreddits about a topic with their self-promotion rules flagged; subreddit_rules reads one community's rules, size and description; account_check reports an account's age, karma, standing and whether its recent posts are removed or hidden from search; post_status says whether a post is live, removed or deleted. Reddit now sends signed-out requests to a login page, so every read runs in your own Chrome, signed in as you, through Microsoft's Playwright Extension (needs Node.js and the extension; the first read asks you to pick a tab). Nothing is posted or changed. The full ThreadFox kit (finding conversations where people ask for what you sell, posting from your own Chrome, an outcome ledger, a 12-module course) is sold separately at https://threadfox.vip.",
+  "author": {
+    "name": "AMF Indiana (ThreadFox)",
+    "email": "support@threadfox.vip",
+    "url": "https://threadfox.vip"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amflimited/threadfox-lite"
+  },
+  "homepage": "https://threadfox.vip",
+  "support": "https://threadfox.vip/help",
+  "icon": "icon.png",
+  "server": {
+    "type": "uv",
+    "entry_point": "src/threadfox_lite/server.py",
+    "mcp_config": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--directory",
+        "${__dirname}",
+        "threadfox-lite"
+      ]
+    }
+  },
+  "tools": [
+    {
+      "name": "find_communities",
+      "description": "Subreddits about a topic, each with its self-promotion rules flagged."
+    },
+    {
+      "name": "subreddit_rules",
+      "description": "A subreddit's rules, size and description, with the self-promotion rules flagged."
+    },
+    {
+      "name": "account_check",
+      "description": "An account's age, karma, standing and whether its recent posts are hidden."
+    },
+    {
+      "name": "post_status",
+      "description": "Whether a Reddit post is still live, removed by moderators or deleted, with score and comments."
+    },
+    {
+      "name": "threadfox_full_kit",
+      "description": "What the full ThreadFox kit adds and where to get it."
+    }
+  ],
+  "keywords": [
+    "reddit",
+    "subreddit",
+    "rules",
+    "marketing",
+    "claude-code",
+    "codex",
+    "mcp"
+  ],
+  "license": "MIT",
+  "compatibility": {
+    "platforms": [
+      "darwin",
+      "linux",
+      "win32"
+    ],
+    "runtimes": {
+      "python": ">=3.10"
+    }
+  }
+}

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/pyproject.toml RENAMED Viewed

@@ -1,12 +1,12 @@
 [project]
 name = "threadfox-lite"
-version = "0.1.1"
+version = "0.2.0"
 description = "Read a subreddit's rules and check whether a Reddit post is still up, from Claude Code, Codex or any MCP client. Free tools from ThreadFox."
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"
 authors = [{ name = "AMF Indiana (ThreadFox)", email = "support@threadfox.vip" }]
-dependencies = ["mcp>=1.2.0,<2", "httpx>=0.27"]
+dependencies = ["mcp>=1.2.0,<2"]
 [project.urls]
 Homepage = "https://threadfox.vip"

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/server.json RENAMED Viewed

@@ -2,8 +2,8 @@
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.amflimited/threadfox-lite",
   "title": "ThreadFox Lite",
-  "description": "Read subreddit rules before posting and check whether a Reddit post is still up. Free and read-only.",
-  "version": "0.1.1",
+  "description": "Find subreddits you may post in, read their rules, check your account and posts. Free, read-only.",
+  "version": "0.2.0",
   "websiteUrl": "https://threadfox.vip",
   "repository": {
     "url": "https://github.com/amflimited/threadfox-lite",
@@ -13,7 +13,7 @@
     {
       "registryType": "pypi",
       "identifier": "threadfox-lite",
-      "version": "0.1.1",
+      "version": "0.2.0",
       "runtimeHint": "uvx",
       "transport": {
         "type": "stdio"
@@ -21,7 +21,7 @@
     },
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/amflimited/threadfox-lite/releases/download/v0.1.1/threadfox-lite-0.1.1.mcpb",
+      "identifier": "https://github.com/amflimited/threadfox-lite/releases/download/v0.2.0/threadfox-lite-0.2.0.mcpb",
       "fileSha256": "0000000000000000000000000000000000000000000000000000000000000000",
       "transport": {
         "type": "stdio"

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/skills/reddit-rules-first/SKILL.md RENAMED Viewed

@@ -9,7 +9,7 @@ Most Reddit promotion fails for the same reasons: the post ignores the community
 ## Before writing
-1. Pick communities where your product answers a question people there already ask. Fit comes before size.
+1. Pick communities where your product answers a question people there already ask. Fit comes before size. With the ThreadFox Lite MCP server, `find_communities` lists candidates with their promotion rules flagged; `account_check` tells you whether your account is old enough and whether your recent posts are being hidden.
 2. Read each community's rules the day you post. With the ThreadFox Lite MCP server, call `subreddit_rules`; otherwise open `https://www.reddit.com/r/<name>/about/rules` and the sidebar.
 3. Look for: self-promotion limits (for example a 10% rule), a weekly promo thread, required flair, link bans, account age or karma minimums. If self-promotion isn't allowed, use the promo thread or don't post the link.

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/src/threadfox_lite/__init__.py RENAMED Viewed

@@ -1,2 +1,2 @@
 """ThreadFox Lite: free, read-only Reddit tools for AI agents."""
-__version__ = "0.1.1"
+__version__ = "0.2.0"

threadfox_lite-0.2.0/src/threadfox_lite/browser.py ADDED Viewed

@@ -0,0 +1,156 @@
+"""Reddit reads through your own signed-in Chrome.
+Reddit now sends every signed-out request, including its public JSON, to a login page. So ThreadFox Lite reads
+the way you do: in your Chrome, signed in as you. It starts Microsoft's Playwright MCP server in extension mode
+(`npx @playwright/mcp --extension`, needs Node.js and the Playwright Extension in Chrome) and runs one small
+fetch of Reddit's JSON inside an old.reddit.com tab per read. Nothing is posted, voted or changed.
+"""
+import atexit
+import glob
+import json
+import os
+import re
+import shutil
+import subprocess
+import threading
+import time
+EXTENSION_URL = "https://chromewebstore.google.com/detail/playwright-extension/mmlmfjhmonkocbjadbfplnigmagldckm"
+SETUP = ("ThreadFox Lite reads Reddit through your own signed-in Chrome, because Reddit now asks everyone to sign in "
+         "before it shows anything. One-time setup: install Node.js (https://nodejs.org), add Microsoft's Playwright "
+         "Extension to Chrome (" + EXTENSION_URL + "), sign in to Reddit in that Chrome, then try again.")
+SPACING = 1.5   # seconds between reads, so the account is never rate-limited
+class SetupError(RuntimeError):
+    """The browser route is not ready; the message says what to do."""
+def find_npx():
+    """npx on PATH, or in the usual Node.js folders (apps started from the Dock or Start menu get a short PATH)."""
+    found = shutil.which("npx")
+    if found:
+        return found
+    home = os.path.expanduser("~")
+    candidates = ["/usr/local/bin/npx", "/opt/homebrew/bin/npx", os.path.join(home, ".volta", "bin", "npx")]
+    candidates += sorted(glob.glob(os.path.join(home, ".nvm", "versions", "node", "*", "bin", "npx")), reverse=True)
+    for base in filter(None, [os.environ.get("ProgramFiles"), os.environ.get("APPDATA")]):
+        candidates += [os.path.join(base, "nodejs", "npx.cmd"), os.path.join(base, "npm", "npx.cmd")]
+    return next((c for c in candidates if os.path.isfile(c)), None)
+class Chrome:
+    """A Playwright MCP child process spoken to over newline-delimited JSON-RPC."""
+    def __init__(self, command=None, timeout=90):
+        self.command = command
+        self.timeout = timeout
+        self.proc = None
+        self.n = 0
+        self.tool = None
+        self.last = 0.0
+        self.lock = threading.Lock()
+    def start(self):
+        if self.proc and self.proc.poll() is None:
+            return
+        cmd = list(self.command or [])
+        env = dict(os.environ)
+        if not cmd:
+            npx = find_npx()
+            if not npx:
+                raise SetupError(SETUP)
+            cmd = [npx, "-y", "@playwright/mcp@latest", "--extension"]
+            env["PATH"] = os.path.dirname(npx) + os.pathsep + env.get("PATH", "")
+        self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+                                     text=True, encoding="utf-8", bufsize=1, env=env)
+        self.request("initialize", {"protocolVersion": "2025-06-18", "capabilities": {},
+                                    "clientInfo": {"name": "threadfox-lite", "version": "1"}}, 120)
+        self.proc.stdin.write(json.dumps({"jsonrpc": "2.0", "method": "notifications/initialized"}) + "\n")
+        self.proc.stdin.flush()
+        names = [t.get("name") for t in self.request("tools/list", {}).get("tools", [])]
+        self.tool = next((n for n in ("browser_run_code_unsafe", "browser_run_code") if n in names), None)
+        if not self.tool:
+            raise SetupError("This Playwright MCP version cannot run a read; update it (npx -y @playwright/mcp@latest).")
+    def request(self, method, params, timeout=None):
+        self.n += 1
+        mid, box = self.n, {}
+        self.proc.stdin.write(json.dumps({"jsonrpc": "2.0", "id": mid, "method": method, "params": params}) + "\n")
+        self.proc.stdin.flush()
+        def read():
+            for line in self.proc.stdout:
+                try:
+                    msg = json.loads(line)
+                except ValueError:
+                    continue
+                if msg.get("id") == mid:
+                    box["msg"] = msg
+                    return
+        reader = threading.Thread(target=read, daemon=True)
+        reader.start()
+        reader.join(timeout or self.timeout)
+        if "msg" not in box:
+            self.close(tidy=False)
+            raise SetupError("Chrome did not answer. Open Chrome, click the Playwright Extension and pick a tab when it "
+                             "asks to connect, then try again. " + SETUP)
+        if "error" in box["msg"]:
+            raise SetupError(box["msg"]["error"].get("message", "browser error"))
+        return box["msg"].get("result", {})
+    def get(self, path):
+        """(status, body) for one Reddit JSON path, fetched in the signed-in old.reddit.com tab."""
+        code = """async (page) => {
+  if (!page.url().startsWith('https://old.reddit.com/')) await page.goto('https://old.reddit.com/robots.txt', {waitUntil: 'domcontentloaded'});
+  const out = await page.evaluate(async (path) => {
+    const r = await fetch(path, {credentials: 'include', headers: {'Accept': 'application/json'}});
+    return {status: r.status, body: r.ok ? await r.json() : null};
+  }, %s);
+  return JSON.stringify(out);
+}""" % json.dumps(path)
+        with self.lock:
+            wait = self.last + SPACING - time.time()
+            if wait > 0:
+                time.sleep(wait)
+            self.start()
+            try:
+                result = self.request("tools/call", {"name": self.tool, "arguments": {"code": code}})
+            finally:
+                self.last = time.time()
+        text = "\n".join(c.get("text", "") for c in result.get("content", []) if c.get("type") == "text")
+        if result.get("isError") or "### Error" in text:
+            message = re.sub(r"^#+\s*Error\s*", "", text).strip()
+            raise SetupError((SETUP if re.search(r"extension not found|install it from", message, re.I) else message[:400]) or SETUP)
+        m = re.search(r'### Result\s*\n(".*?")\s*\n', text + "\n", re.S)
+        if not m:
+            raise SetupError("No answer came back from Chrome: " + text[:200])
+        out = json.loads(json.loads(m.group(1)))
+        return out.get("status"), out.get("body")
+    def close(self, tidy=True):
+        """Close this session's tab in Chrome, then end the Playwright process."""
+        if not self.proc:
+            return
+        if tidy and self.proc.poll() is None:
+            try:
+                self.request("tools/call", {"name": "browser_tabs", "arguments": {"action": "close"}}, timeout=10)
+            except Exception:
+                pass
+        try:
+            self.proc.kill()
+        except Exception:
+            pass
+        self.proc = None
+_chrome = None
+def get(path):
+    global _chrome
+    if _chrome is None:
+        command = os.environ.get("THREADFOX_LITE_BROWSER_CMD")
+        _chrome = Chrome(command.split() if command else None)
+        atexit.register(_chrome.close)
+    return _chrome.get(path)

threadfox_lite-0.2.0/src/threadfox_lite/reddit.py ADDED Viewed

@@ -0,0 +1,176 @@
+"""Read-only Reddit reads for the ThreadFox Lite tools. Each read goes through your own signed-in Chrome
+(browser.py); nothing is posted, voted or changed. Every function takes an optional `get(path) -> (status, body)`
+so the tests can stand in for Reddit."""
+import re
+import time
+from urllib.parse import quote, urlsplit
+from . import browser
+PROMO = re.compile(r"self[- ]?promo|promot|advertis|spam|affiliate|referral|\b10\s*%|link[- ]?drop|no links?\b|marketing|sell|product|business", re.I)
+PROMO_THREAD = re.compile(r"(weekly|monthly|daily|dedicated|pinned|sticky|stickied)[^.\n]{0,40}(thread|post|megathread)|megathread|"
+                          r"self[- ]?promo(tion)? (thread|saturday|sunday|day)", re.I)
+SUB = re.compile(r"^[A-Za-z0-9_]{2,21}$")
+USER = re.compile(r"^[A-Za-z0-9_-]{3,20}$")
+RATE = "Reddit asked us to slow down (HTTP 429). Wait a few minutes before the next check."
+def _read(get, path):
+    """(status, body), or an error dict when the browser route is not set up."""
+    try:
+        return (get or browser.get)(path), None
+    except browser.SetupError as exc:
+        return (None, None), str(exc)
+def subreddit_rules(name: str, get=None) -> dict:
+    name = name.strip().removeprefix("/").removeprefix("r/").strip("/")
+    if not SUB.match(name):
+        return {"error": "Give a subreddit name like 'SaaS' or 'r/SaaS'."}
+    (status, rules), err = _read(get, f"/r/{name}/about/rules.json?raw_json=1")
+    if err:
+        return {"subreddit": name, "error": err, "open_instead": f"https://www.reddit.com/r/{name}/about/rules"}
+    if status == 429:
+        return {"subreddit": name, "error": RATE}
+    if status != 200 or not isinstance(rules, dict):
+        return {"subreddit": name, "error": f"r/{name} is private, banned or does not exist (HTTP {status})."}
+    (status, about), err = _read(get, f"/r/{name}/about.json?raw_json=1")
+    data = (about or {}).get("data", {}) if status == 200 and isinstance(about, dict) else {}
+    items = []
+    for r in rules.get("rules", []):
+        text = f"{r.get('short_name', '')}\n{r.get('description', '')}".strip()
+        items.append({"rule": r.get("short_name", ""), "details": (r.get("description") or "")[:1200],
+                      "applies_to": r.get("kind", "all"), "mentions_promotion": bool(PROMO.search(text))})
+    return {
+        "subreddit": data.get("display_name", name),
+        "subscribers": data.get("subscribers"),
+        "description": (data.get("public_description") or "")[:500],
+        "rules": items,
+        "promotion_rules": [i["rule"] for i in items if i["mentions_promotion"]],
+        "read_before_posting": "Follow every rule above. If a rule limits self-promotion, use the community's promo thread or don't post the link. Write a new post for this community; never paste the same post in several.",
+    }
+def post_status(url: str, get=None) -> dict:
+    try:
+        parts = urlsplit(url.strip())
+    except ValueError:
+        return {"error": "Give a Reddit post URL."}
+    host = (parts.hostname or "").lower()
+    m = re.match(r"^/r/[^/]+/comments/([a-z0-9]+)", parts.path or "")
+    if not host.endswith("reddit.com") or not m:
+        return {"error": "Give a full post URL like https://www.reddit.com/r/SaaS/comments/abc123/title/"}
+    (status, body), err = _read(get, f"/comments/{m.group(1)}.json?raw_json=1&limit=1")
+    if err:
+        return {"error": err, "open_instead": url.strip()}
+    if status == 404:
+        return {"status": "not_found", "id": m.group(1)}
+    if status == 429:
+        return {"error": RATE}
+    if status != 200 or not isinstance(body, list):
+        return {"error": f"Reddit answered HTTP {status} for this post."}
+    post = body[0]["data"]["children"][0]["data"]
+    removed = post.get("removed_by_category")
+    status = "removed" if removed else ("deleted" if post.get("author") == "[deleted]" or post.get("selftext") == "[deleted]" else "live")
+    return {
+        "status": status, "removed_by": removed, "title": post.get("title"), "subreddit": post.get("subreddit"),
+        "score": post.get("score"), "comments": post.get("num_comments"), "locked": post.get("locked"),
+        "shown_in_search": post.get("is_robot_indexable"),
+        "created_utc": post.get("created_utc"), "permalink": "https://www.reddit.com" + (post.get("permalink") or ""),
+        "note": "Check again at 1, 6 and 24 hours. If a community removes you twice, stop posting there.",
+    }
+def account_check(username: str, get=None) -> dict:
+    """An account's age, karma and standing, and whether its recent posts are hidden from other people."""
+    name = username.strip().removeprefix("/").removeprefix("u/").strip("/")
+    if not USER.match(name):
+        return {"error": "Give a Reddit username like 'spez' or 'u/spez'."}
+    (status, about), err = _read(get, f"/user/{name}/about.json?raw_json=1")
+    if err:
+        return {"account": name, "error": err, "open_instead": f"https://www.reddit.com/user/{name}"}
+    if status == 429:
+        return {"account": name, "error": RATE}
+    if status == 404:
+        return {"account": name, "status": "not_found",
+                "meaning": "Reddit shows no profile under this name: it does not exist, was deleted, or is suspended or hidden."}
+    if status != 200 or not isinstance(about, dict):
+        return {"account": name, "error": f"Reddit answered HTTP {status} for this account."}
+    data = about.get("data", {})
+    if data.get("is_suspended"):
+        return {"account": name, "status": "suspended",
+                "meaning": "Reddit has suspended this account. Nothing it posts will be seen until the suspension ends."}
+    (status, posts), err = _read(get, f"/user/{name}/submitted.json?raw_json=1&limit=10")
+    recent = []
+    for child in ((posts or {}).get("data", {}).get("children", []) if status == 200 and isinstance(posts, dict) else [])[:10]:
+        d = child.get("data", {})
+        recent.append({"subreddit": d.get("subreddit"), "title": (d.get("title") or "")[:120], "score": d.get("score"),
+                       "comments": d.get("num_comments"), "removed_by": d.get("removed_by_category"),
+                       "hidden_from_search": d.get("is_robot_indexable") is False,
+                       "permalink": "https://www.reddit.com" + (d.get("permalink") or "")})
+    days = int((time.time() - (data.get("created_utc") or time.time())) // 86400)
+    karma = (data.get("link_karma") or 0) + (data.get("comment_karma") or 0)
+    notes = []
+    if days < 30:
+        notes.append(f"The account is {days} days old; many communities require 7 to 30 days before you can post.")
+    if karma < 100:
+        notes.append(f"{karma} karma; many communities require 10 to 100. Build it with genuinely useful comments first.")
+    removed = [r for r in recent if r["removed_by"]]
+    hidden = [r for r in recent if r["hidden_from_search"] and not r["removed_by"]]
+    if len(removed) >= 2:
+        notes.append(f"{len(removed)} of the last {len(recent)} posts were removed. Read those communities' rules before posting again.")
+    if recent and len(hidden) >= max(2, len(recent) // 2):
+        notes.append("Most recent posts are hidden from search and listings without a moderator removal: Reddit's spam filter "
+                     "or a shadowban. Check each post in a window where you are not signed in, and appeal at https://www.reddit.com/appeal.")
+    return {"account": data.get("name", name), "status": "active", "account_age_days": days,
+            "post_karma": data.get("link_karma"), "comment_karma": data.get("comment_karma"),
+            "verified_email": data.get("has_verified_email"), "recent_posts": recent,
+            "notes": notes or ["Enough age and karma for most communities, and recent posts are not hidden. Each community's rules still apply."]}
+def find_communities(topic: str, limit: int = 5, get=None) -> dict:
+    """Subreddits about a topic, each with its self-promotion rules flagged."""
+    topic = (topic or "").strip()
+    if not 2 <= len(topic) <= 100:
+        return {"error": "Describe the topic in a few words, e.g. 'bakery marketing' or 'indie games'."}
+    limit = max(1, min(int(limit or 5), 8))
+    # Reddit's community search needs every word to match, so a two-word topic can find almost nothing.
+    # The whole topic goes first; when it finds too few, each main word is searched on its own.
+    words = re.findall(r"[A-Za-z0-9]{3,}", topic)
+    searches = [topic] + (words[:3] if len(words) > 1 else [])
+    subs, seen = [], set()
+    for q in searches:
+        if len(subs) >= limit:
+            break
+        (status, found), err = _read(get, f"/subreddits/search.json?raw_json=1&q={quote(q)}&limit=25&include_over_18=off")
+        if err:
+            return {"topic": topic, "error": err, "open_instead": f"https://www.reddit.com/search/?q={quote(topic)}&type=communities"}
+        if status == 429:
+            return {"topic": topic, "error": RATE}
+        if status != 200 or not isinstance(found, dict):
+            return {"topic": topic, "error": f"Reddit answered HTTP {status} for this search."}
+        for child in found.get("data", {}).get("children", []):
+            d = child.get("data", {})
+            name = (d.get("display_name") or "").lower()
+            if name and name not in seen and d.get("subreddit_type") == "public" and not d.get("over18") and (d.get("subscribers") or 0) >= 500:
+                seen.add(name); subs.append(d)
+    subs = subs[:limit]
+    out = []
+    for d in subs:
+        name = d.get("display_name")
+        (status, rules), err = _read(get, f"/r/{name}/about/rules.json?raw_json=1")
+        if err:
+            return {"topic": topic, "error": err, "communities": out}
+        items = rules.get("rules", []) if status == 200 and isinstance(rules, dict) else []
+        texts = [f"{r.get('short_name', '')}\n{r.get('description', '')}" for r in items]
+        promo = [r.get("short_name", "") for r, text in zip(items, texts) if PROMO.search(text)]
+        thread = bool(PROMO_THREAD.search(" ".join(texts) + " " + (d.get("public_description") or "")))
+        out.append({"subreddit": name, "subscribers": d.get("subscribers"), "description": (d.get("public_description") or "")[:300],
+                    "promotion_rules": promo, "promo_thread_mentioned": thread, "rules_read": status == 200,
+                    "verdict": ("rules not readable: open them before posting" if status != 200 else
+                                "self-promotion limited: use the promo thread it mentions, or answer questions without links" if promo and thread else
+                                "self-promotion limited: read these rules before any link" if promo else
+                                "no rule mentions promotion: still read every rule, disclose, and post something useful"),
+                    "rules_url": f"https://www.reddit.com/r/{name}/about/rules"})
+    return {"topic": topic, "communities": out,
+            "next": "Call subreddit_rules on the ones that fit before writing anything, and write a separate post for each."}

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/src/threadfox_lite/server.py RENAMED Viewed

@@ -26,6 +26,20 @@ def post_status(url: str) -> dict:
     return reddit.post_status(url)
+@mcp.tool()
+def account_check(username: str) -> dict:
+    """Check a Reddit account before posting: whether other people can see it (not shadowbanned or suspended),
+    its age and karma, and its recent posts with any removals."""
+    return reddit.account_check(username)
+@mcp.tool()
+def find_communities(topic: str, limit: int = 5) -> dict:
+    """Find subreddits about a topic, each with its self-promotion rules flagged and whether it mentions a promo thread.
+    Use a few words, e.g. 'bakery marketing' or 'indie games'."""
+    return reddit.find_communities(topic, limit)
 @mcp.tool()
 def threadfox_full_kit() -> dict:
     """How to get the full ThreadFox kit: your AI reads the rules, writes a post that fits each community,
@@ -36,10 +50,12 @@ def threadfox_full_kit() -> dict:
                 "next_step": "Open https://threadfox.vip/redeem, paste your MCP Marketplace license key and your email, and you land in your private ThreadFox library (one-command install, lessons, full download).",
                 "support": "support@threadfox.vip"}
     return {"licensed": False,
-            "what_it_adds": ["Publishing from your own signed-in Chrome, no Reddit API keys", "Replies to comments",
+            "what_it_adds": ["Finds conversations where people already ask for what you sell, and drafts replies you approve before anything is posted",
+                             "Publishing from your own signed-in Chrome, no Reddit API keys", "Replies to comments",
                              "A ledger of every post and outcome, and it stops where a community removed you",
                              "12-module course, 48 prompts"],
             "proof": "Built from our own run: 978,227 recorded views from two days of posts (Sept 20-21 UTC), with no ad spend. Our result, not a promise of yours.",
+            "works_in": "Claude Desktop (one file, no terminal), Claude Code and Codex",
             "get_it": "https://threadfox.vip ($49 once, 30-day refund) or ThreadFox on MCP Marketplace"}

threadfox_lite-0.2.0/tests/test_reddit.py ADDED Viewed

@@ -0,0 +1,132 @@
+import sys, textwrap, time, unittest
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from threadfox_lite import browser, reddit
+def fake(routes):
+    """A stand-in for the Chrome route: path (without its query) -> (status, body)."""
+    seen = []
+    def get(path):
+        seen.append(path)
+        return routes.get(path.split("?")[0], (404, None))
+    get.seen = seen
+    return get
+RULES = {"rules": [{"short_name": "No self-promotion", "description": "Keep promo to the weekly thread", "kind": "all"},
+                   {"short_name": "Be kind", "description": "", "kind": "all"}]}
+class Tools(unittest.TestCase):
+    def test_rules_flag_promotion(self):
+        get = fake({"/r/SaaS/about/rules.json": (200, RULES),
+                    "/r/SaaS/about.json": (200, {"data": {"display_name": "SaaS", "subscribers": 400000, "public_description": "SaaS"}})})
+        r = reddit.subreddit_rules("r/SaaS", get=get)
+        self.assertEqual(r["promotion_rules"], ["No self-promotion"])
+        self.assertEqual(r["subscribers"], 400000)
+        self.assertTrue(all("raw_json=1" in p for p in get.seen))
+        self.assertIn("error", reddit.subreddit_rules("not a sub!", get=get))
+        self.assertIn("private, banned", reddit.subreddit_rules("gone", get=get)["error"])
+    def test_post_status(self):
+        live = [{"data": {"children": [{"data": {"title": "T", "subreddit": "SaaS", "score": 5, "num_comments": 2, "author": "me",
+                                                 "removed_by_category": None, "locked": False, "is_robot_indexable": True,
+                                                 "permalink": "/r/SaaS/comments/abc123/t/"}}]}}]
+        get = fake({"/comments/abc123.json": (200, live)})
+        r = reddit.post_status("https://www.reddit.com/r/SaaS/comments/abc123/t/", get=get)
+        self.assertEqual((r["status"], r["shown_in_search"]), ("live", True))
+        live[0]["data"]["children"][0]["data"]["removed_by_category"] = "moderator"
+        self.assertEqual(reddit.post_status("https://old.reddit.com/r/SaaS/comments/abc123/t/", get=get)["status"], "removed")
+        self.assertIn("error", reddit.post_status("https://example.com/x", get=get))
+        self.assertEqual(reddit.post_status("https://www.reddit.com/r/SaaS/comments/zzz999/t/", get=get)["status"], "not_found")
+class AccountAndCommunities(unittest.TestCase):
+    def test_account_new_low_karma_with_removed_and_hidden_posts(self):
+        posts = {"data": {"children": [
+            {"data": {"subreddit": "SaaS", "title": "a", "removed_by_category": "moderator", "is_robot_indexable": False, "permalink": "/r/SaaS/comments/a/x/"}},
+            {"data": {"subreddit": "startups", "title": "b", "removed_by_category": "moderator", "is_robot_indexable": False, "permalink": "/r/startups/comments/b/y/"}},
+            {"data": {"subreddit": "webdev", "title": "c", "removed_by_category": None, "is_robot_indexable": False, "permalink": "/r/webdev/comments/c/z/"}},
+            {"data": {"subreddit": "webdev", "title": "d", "removed_by_category": None, "is_robot_indexable": False, "permalink": "/r/webdev/comments/d/z/"}}]}}
+        get = fake({"/user/newbie/about.json": (200, {"data": {"name": "newbie", "created_utc": time.time() - 3 * 86400,
+                                                               "link_karma": 1, "comment_karma": 4}}),
+                    "/user/newbie/submitted.json": (200, posts)})
+        r = reddit.account_check("u/newbie", get=get)
+        self.assertEqual((r["status"], r["account_age_days"]), ("active", 3))
+        self.assertEqual(len(r["notes"]), 4)
+        self.assertTrue(any("shadowban" in n for n in r["notes"]))
+    def test_account_missing_or_suspended(self):
+        get = fake({"/user/gone/about.json": (200, {"data": {"name": "gone", "is_suspended": True}})})
+        self.assertEqual(reddit.account_check("ghost", get=get)["status"], "not_found")
+        self.assertEqual(reddit.account_check("gone", get=get)["status"], "suspended")
+        self.assertIn("error", reddit.account_check("not a name!", get=get))
+    def test_find_communities_flags_promotion_rules(self):
+        subs = {"data": {"children": [
+            {"data": {"display_name": "Baking", "subscribers": 900000, "subreddit_type": "public", "over18": False, "public_description": "Bake"}},
+            {"data": {"display_name": "BakeryOwners", "subscribers": 12000, "subreddit_type": "public", "over18": False, "public_description": "Run a bakery"}},
+            {"data": {"display_name": "tinybake", "subscribers": 40, "subreddit_type": "public", "over18": False}},
+            {"data": {"display_name": "privatebake", "subscribers": 9000, "subreddit_type": "private", "over18": False}}]}}
+        get = fake({"/subreddits/search.json": (200, subs),
+                    "/r/Baking/about/rules.json": (200, {"rules": [{"short_name": "No self-promotion", "description": "Use the weekly promo thread"}]}),
+                    "/r/BakeryOwners/about/rules.json": (200, {"rules": [{"short_name": "Be kind", "description": ""}]})})
+        r = reddit.find_communities("bakery owners", get=get)
+        self.assertEqual([c["subreddit"] for c in r["communities"]], ["Baking", "BakeryOwners"])
+        self.assertEqual(r["communities"][0]["promotion_rules"], ["No self-promotion"])
+        self.assertTrue(r["communities"][0]["promo_thread_mentioned"])
+        self.assertIn("promo thread", r["communities"][0]["verdict"])
+        self.assertIn("no rule mentions promotion", r["communities"][1]["verdict"])
+        self.assertIn("q=bakery%20owners", get.seen[0])
+        self.assertIn("error", reddit.find_communities("x", get=get))
+    def test_a_topic_that_finds_too_little_is_searched_word_by_word(self):
+        calls = []
+        def get(path):
+            calls.append(path)
+            if "q=bakery%20marketing" in path:
+                return 200, {"data": {"children": [{"data": {"display_name": "bakerymarketing", "subscribers": 2, "subreddit_type": "public"}}]}}
+            if "q=bakery&" in path:
+                return 200, {"data": {"children": [{"data": {"display_name": "Baking", "subscribers": 4600000, "subreddit_type": "public"}}]}}
+            if "q=marketing&" in path:
+                return 200, {"data": {"children": [{"data": {"display_name": "marketing", "subscribers": 2000000, "subreddit_type": "public"}},
+                                                   {"data": {"display_name": "Baking", "subscribers": 4600000, "subreddit_type": "public"}}]}}
+            return 200, {"rules": []}
+        r = reddit.find_communities("bakery marketing", limit=5, get=get)
+        self.assertEqual([c["subreddit"] for c in r["communities"]], ["Baking", "marketing"])
+class Setup(unittest.TestCase):
+    def test_missing_setup_is_explained_not_raised(self):
+        def get(path):
+            raise browser.SetupError(browser.SETUP)
+        for r in (reddit.subreddit_rules("SaaS", get=get), reddit.account_check("someone", get=get),
+                  reddit.post_status("https://www.reddit.com/r/SaaS/comments/abc123/t/", get=get), reddit.find_communities("bakery", get=get)):
+            self.assertIn("Playwright Extension", r["error"]); self.assertIn("nodejs.org", r["error"])
+    def test_chrome_client_reads_through_a_playwright_mcp(self):
+        """The real client against a stand-in Playwright MCP that answers the way the real one formats results."""
+        stub = textwrap.dedent('''
+            import json, sys
+            for line in sys.stdin:
+                msg = json.loads(line)
+                if "id" not in msg: continue
+                if msg["method"] == "initialize": out = {"protocolVersion": "2025-06-18", "capabilities": {}}
+                elif msg["method"] == "tools/list": out = {"tools": [{"name": "browser_run_code_unsafe"}, {"name": "browser_tabs"}]}
+                elif msg["params"]["name"] == "browser_tabs": out = {"content": []}
+                else:
+                    code = msg["params"]["arguments"]["code"]
+                    body = {"status": 200, "body": {"ok": "old.reddit.com/robots.txt" in code and "/r/SaaS/about.json" in code}}
+                    out = {"content": [{"type": "text", "text": "### Result\\n" + json.dumps(json.dumps(body)) + "\\n"}]}
+                sys.stdout.write(json.dumps({"jsonrpc": "2.0", "id": msg["id"], "result": out}) + "\\n"); sys.stdout.flush()
+        ''')
+        chrome = browser.Chrome([sys.executable, "-c", stub], timeout=20)
+        try:
+            self.assertEqual(chrome.get("/r/SaaS/about.json?raw_json=1"), (200, {"ok": True}))
+        finally:
+            chrome.close()
+if __name__ == "__main__":
+    unittest.main()

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/uv.lock RENAMED Viewed

@@ -859,18 +859,14 @@ wheels = [
 [[package]]
 name = "threadfox-lite"
-version = "0.1.1"
+version = "0.2.0"
 source = { editable = "." }
 dependencies = [
-    { name = "httpx" },
     { name = "mcp" },
 ]
 [package.metadata]
-requires-dist = [
-    { name = "httpx", specifier = ">=0.27" },
-    { name = "mcp", specifier = ">=1.2.0,<2" },
-]
+requires-dist = [{ name = "mcp", specifier = ">=1.2.0,<2" }]
 [[package]]
 name = "typing-extensions"

threadfox_lite-0.1.1/.claude-plugin/plugin.json DELETED Viewed

@@ -1,20 +0,0 @@
-{
-  "name": "threadfox-lite",
-  "version": "0.1.1",
-  "description": "Free, read-only Reddit tools: read a subreddit's rules before posting and check whether a post stayed up, plus the reddit-rules-first skill.",
-  "author": {
-    "name": "ThreadFox (AMF Indiana)",
-    "email": "support@threadfox.vip",
-    "url": "https://threadfox.vip"
-  },
-  "homepage": "https://threadfox.vip",
-  "repository": "https://github.com/amflimited/threadfox-lite",
-  "license": "MIT",
-  "keywords": ["reddit", "subreddit-rules", "marketing", "mcp", "skills"],
-  "mcpServers": {
-    "threadfox-lite": {
-      "command": "uv",
-      "args": ["run", "--directory", "${CLAUDE_PLUGIN_ROOT}", "threadfox-lite"]
-    }
-  }
-}

threadfox_lite-0.1.1/manifest.json DELETED Viewed

@@ -1,39 +0,0 @@
-{
-  "manifest_version": "0.4",
-  "name": "threadfox-lite",
-  "display_name": "ThreadFox Lite",
-  "version": "0.1.1",
-  "description": "Read a subreddit's rules and check whether a Reddit post is still up. Free, read-only tools from ThreadFox.",
-  "long_description": "Two free, read-only Reddit tools for Claude and any MCP client. subreddit_rules returns a subreddit's rules, size and description and flags the rules that mention self-promotion, so your AI reads them before it writes a post. post_status tells you whether a post is still live, removed by moderators or deleted, with its score and comment count. No login, no posting and no Reddit API keys: each call is one request to Reddit's public JSON. Reddit blocks many cloud and VPN networks, so run it from your own computer. The full ThreadFox kit (posting from your own Chrome, replies, an outcome ledger, a 12-module course) is sold separately at https://threadfox.vip.",
-  "author": {
-    "name": "AMF Indiana (ThreadFox)",
-    "email": "support@threadfox.vip",
-    "url": "https://threadfox.vip"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/amflimited/threadfox-lite"
-  },
-  "homepage": "https://threadfox.vip",
-  "support": "https://threadfox.vip/help",
-  "icon": "icon.png",
-  "server": {
-    "type": "uv",
-    "entry_point": "src/threadfox_lite/server.py",
-    "mcp_config": {
-      "command": "uv",
-      "args": ["run", "--directory", "${__dirname}", "threadfox-lite"]
-    }
-  },
-  "tools": [
-    {"name": "subreddit_rules", "description": "A subreddit's rules, size and description, with the self-promotion rules flagged."},
-    {"name": "post_status", "description": "Whether a Reddit post is still live, removed by moderators or deleted, with score and comments."},
-    {"name": "threadfox_full_kit", "description": "What the full ThreadFox kit adds and where to get it."}
-  ],
-  "keywords": ["reddit", "subreddit", "rules", "marketing", "claude-code", "codex", "mcp"],
-  "license": "MIT",
-  "compatibility": {
-    "platforms": ["darwin", "linux", "win32"],
-    "runtimes": {"python": ">=3.10"}
-  }
-}

threadfox_lite-0.1.1/src/threadfox_lite/reddit.py DELETED Viewed

@@ -1,88 +0,0 @@
-"""Read-only calls to Reddit's public JSON. No login, no posting, one request per tool call."""
-import re
-from urllib.parse import urlsplit
-import httpx
-UA = "threadfox-lite/0.1.1 (+https://threadfox.vip; read-only rules and post-status checks)"
-PROMO = re.compile(r"self[- ]?promo|promot|advertis|spam|affiliate|referral|\b10\s*%|link[- ]?drop|no links?\b|marketing|sell|product|business", re.I)
-SUB = re.compile(r"^[A-Za-z0-9_]{2,21}$")
-BLOCKED = ("Reddit refused this network (it blocks many servers, VPNs and cloud machines). Run the tool from your own "
-           "computer's connection, or open the page in a browser.")
-def _blocked(resp):
-    """Reddit's network block is a 403 whose body is not JSON (plain 'Blocked'); a private subreddit's 403 is JSON."""
-    if resp.status_code != 403:
-        return False
-    try:
-        resp.json()
-        return False
-    except ValueError:
-        return True
-def _client(transport=None):
-    return httpx.Client(headers={"User-Agent": UA}, timeout=15, follow_redirects=True, transport=transport)
-def subreddit_rules(name: str, transport=None) -> dict:
-    name = name.strip().removeprefix("/").removeprefix("r/").strip("/")
-    if not SUB.match(name):
-        return {"error": "Give a subreddit name like 'SaaS' or 'r/SaaS'."}
-    with _client(transport) as c:
-        rules = c.get(f"https://www.reddit.com/r/{name}/about/rules.json")
-        about = c.get(f"https://www.reddit.com/r/{name}/about.json")
-    blocked = _blocked(rules) or _blocked(about)
-    if blocked:
-        return {"subreddit": name, "error": BLOCKED, "open_instead": f"https://www.reddit.com/r/{name}/about/rules"}
-    if rules.status_code in (403, 404) or about.status_code in (403, 404):
-        return {"subreddit": name, "error": f"r/{name} is private, banned or does not exist (HTTP {rules.status_code})."}
-    if rules.status_code == 429 or about.status_code == 429:
-        return {"subreddit": name, "error": "Reddit rate-limited this request. Wait a minute and try again."}
-    rules.raise_for_status(); about.raise_for_status()
-    data = about.json().get("data", {})
-    items = []
-    for r in rules.json().get("rules", []):
-        text = f"{r.get('short_name', '')}\n{r.get('description', '')}".strip()
-        items.append({"rule": r.get("short_name", ""), "details": (r.get("description") or "")[:1200],
-                      "applies_to": r.get("kind", "all"), "mentions_promotion": bool(PROMO.search(text))})
-    return {
-        "subreddit": data.get("display_name", name),
-        "subscribers": data.get("subscribers"),
-        "description": (data.get("public_description") or "")[:500],
-        "rules": items,
-        "promotion_rules": [i["rule"] for i in items if i["mentions_promotion"]],
-        "read_before_posting": "Follow every rule above. If a rule limits self-promotion, use the community's promo thread or don't post the link. Write a new post for this community; never paste the same post in several.",
-    }
-def post_status(url: str, transport=None) -> dict:
-    try:
-        parts = urlsplit(url.strip())
-    except ValueError:
-        return {"error": "Give a Reddit post URL."}
-    host = (parts.hostname or "").lower()
-    m = re.match(r"^/r/[^/]+/comments/([a-z0-9]+)", parts.path or "")
-    if not host.endswith("reddit.com") or not m:
-        return {"error": "Give a full post URL like https://www.reddit.com/r/SaaS/comments/abc123/title/"}
-    with _client(transport) as c:
-        resp = c.get(f"https://www.reddit.com/comments/{m.group(1)}.json", params={"raw_json": 1, "limit": 1})
-    if _blocked(resp):
-        return {"error": BLOCKED, "open_instead": url.strip()}
-    if resp.status_code == 404:
-        return {"status": "not_found", "id": m.group(1)}
-    if resp.status_code == 429:
-        return {"error": "Reddit rate-limited this request. Wait a minute and try again."}
-    resp.raise_for_status()
-    post = resp.json()[0]["data"]["children"][0]["data"]
-    removed = post.get("removed_by_category")
-    status = "removed" if removed else ("deleted" if post.get("author") == "[deleted]" or post.get("selftext") == "[deleted]" else "live")
-    return {
-        "status": status, "removed_by": removed, "title": post.get("title"), "subreddit": post.get("subreddit"),
-        "score": post.get("score"), "comments": post.get("num_comments"), "locked": post.get("locked"),
-        "created_utc": post.get("created_utc"), "permalink": "https://www.reddit.com" + (post.get("permalink") or ""),
-        "note": "Check again at 1, 6 and 24 hours. If a community removes you twice, stop posting there.",
-    }

threadfox_lite-0.1.1/tests/test_reddit.py DELETED Viewed

@@ -1,42 +0,0 @@
-import json, sys, unittest
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
-import httpx
-from threadfox_lite import reddit
-def transport(routes):
-    def handler(request):
-        for key, (status, body) in routes.items():
-            if key in str(request.url):
-                return httpx.Response(status, json=body)
-        return httpx.Response(404, json={})
-    return httpx.MockTransport(handler)
-class Tools(unittest.TestCase):
-    def test_rules_flag_promotion(self):
-        t = transport({"/about/rules.json": (200, {"rules": [{"short_name": "No self-promotion", "description": "Keep promo to the weekly thread", "kind": "all"},
-                                                            {"short_name": "Be kind", "description": "", "kind": "all"}]}),
-                       "/about.json": (200, {"data": {"display_name": "SaaS", "subscribers": 400000, "public_description": "SaaS"}})})
-        r = reddit.subreddit_rules("r/SaaS", transport=t)
-        self.assertEqual(r["promotion_rules"], ["No self-promotion"])
-        self.assertEqual(r["subscribers"], 400000)
-        self.assertIn("error", reddit.subreddit_rules("not a sub!", transport=t))
-    def test_post_status(self):
-        live = [{"data": {"children": [{"data": {"title": "T", "subreddit": "SaaS", "score": 5, "num_comments": 2, "author": "me",
-                                                 "removed_by_category": None, "locked": False, "permalink": "/r/SaaS/comments/abc123/t/"}}]}}]
-        t = transport({"/comments/abc123.json": (200, live)})
-        self.assertEqual(reddit.post_status("https://www.reddit.com/r/SaaS/comments/abc123/t/", transport=t)["status"], "live")
-        live[0]["data"]["children"][0]["data"]["removed_by_category"] = "moderator"
-        self.assertEqual(reddit.post_status("https://old.reddit.com/r/SaaS/comments/abc123/t/", transport=t)["status"], "removed")
-        self.assertIn("error", reddit.post_status("https://example.com/x", transport=t))
-class Blocked(unittest.TestCase):
-    def test_network_block_is_reported_as_such(self):
-        t = httpx.MockTransport(lambda req: httpx.Response(403, text="Blocked"))
-        r = reddit.subreddit_rules("SaaS", transport=t)
-        self.assertIn("refused this network", r["error"])
-        self.assertIn("refused this network", reddit.post_status("https://www.reddit.com/r/SaaS/comments/abc123/t/", transport=t)["error"])
-if __name__ == "__main__":
-    unittest.main()

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/.github/workflows/publish.yml RENAMED Viewed

File without changes

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/.gitignore RENAMED Viewed

File without changes

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/.mcpbignore RENAMED Viewed

File without changes

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/LICENSE RENAMED Viewed

File without changes

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/glama.json RENAMED Viewed

File without changes

{threadfox_lite-0.1.1 → threadfox_lite-0.2.0}/icon.png RENAMED Viewed

File without changes

threadfox-lite 0.1.1__tar.gz → 0.2.0__tar.gz

threadfox-lite 0.1.1tar.gz → 0.2.0tar.gz