threadfox-lite 0.2.3__tar.gz → 0.2.5__tar.gz

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/.claude-plugin/marketplace.json

@@ -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.2.3",
+      "version": "0.2.5",
       "category": "marketing",
       "homepage": "https://threadfox.vip"
     }

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "threadfox-lite",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "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)",

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/LAUNCHGUIDE.md

@@ -11,7 +11,7 @@ This server (ThreadFox Lite) runs locally and gives every user four free, read-o
 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 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.
+MCP_LICENSE_KEY (optional): your MCP Marketplace license key. The read-only tools work without it. Requires uv (uvx), Python 3.10+ and Microsoft's Playwright Extension in the Chrome where you are signed in to Reddit.
 
 ## Category
 Marketing

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: threadfox-lite
-Version: 0.2.3
+Version: 0.2.5
 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
@@ -21,7 +21,7 @@ Free, read-only Reddit tools for Claude Desktop, Claude Code, Codex and any MCP
 - `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`: 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).
 
-**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.
+**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: Microsoft's [Playwright Extension](https://chromewebstore.google.com/detail/playwright-extension/mmlmfjhmonkocbjadbfplnigmagldckm) in the Chrome where you are signed in to Reddit. Node.js is fetched for you if you don't have it (the official build from nodejs.org into `~/.threadfox/runtime`, checked against its published SHA-256; nothing installed system-wide). It stays light on your computer: one Reddit read at a time across every ThreadFox app on the machine, and its Chrome connection closes after 10 idle minutes and never leaves background processes behind. The first read asks you to pick a tab in Chrome.
 
 ## Install
 

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/README.md

@@ -8,7 +8,7 @@ Free, read-only Reddit tools for Claude Desktop, Claude Code, Codex and any MCP
 - `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`: 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).
 
-**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.
+**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: Microsoft's [Playwright Extension](https://chromewebstore.google.com/detail/playwright-extension/mmlmfjhmonkocbjadbfplnigmagldckm) in the Chrome where you are signed in to Reddit. Node.js is fetched for you if you don't have it (the official build from nodejs.org into `~/.threadfox/runtime`, checked against its published SHA-256; nothing installed system-wide). It stays light on your computer: one Reddit read at a time across every ThreadFox app on the machine, and its Chrome connection closes after 10 idle minutes and never leaves background processes behind. The first read asks you to pick a tab in Chrome.
 
 ## Install
 

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/manifest.json

@@ -2,9 +2,9 @@
   "manifest_version": "0.4",
   "name": "threadfox-lite",
   "display_name": "ThreadFox Lite",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "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.",
+  "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 only the extension: Node.js is fetched automatically when missing; 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",

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "threadfox-lite"
-version = "0.2.3"
+version = "0.2.5"
 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" }

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.amflimited/threadfox-lite",
   "title": "ThreadFox Lite",
   "description": "Find subreddits you may post in, read their rules, check your account and posts. Free, read-only.",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "websiteUrl": "https://threadfox.vip",
   "repository": {
     "url": "https://github.com/amflimited/threadfox-lite",
@@ -13,7 +13,7 @@
     {
       "registryType": "pypi",
       "identifier": "threadfox-lite",
-      "version": "0.2.3",
+      "version": "0.2.5",
       "runtimeHint": "uvx",
       "transport": {
         "type": "stdio"
@@ -21,7 +21,7 @@
     },
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/amflimited/threadfox-lite/releases/download/v0.2.3/threadfox-lite-0.2.3.mcpb",
+      "identifier": "https://github.com/amflimited/threadfox-lite/releases/download/v0.2.5/threadfox-lite-0.2.5.mcpb",
       "fileSha256": "0000000000000000000000000000000000000000000000000000000000000000",
       "transport": {
         "type": "stdio"

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/src/threadfox_lite/__init__.py

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

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/src/threadfox_lite/browser.py

@@ -2,41 +2,29 @@
 
 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.
+(`npx @playwright/mcp --extension`; node.py fetches Node.js when none is installed, and you add the Playwright
+Extension to 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 sys
 import threading
 import time
 
+from . import process
+from .node import SetupError, ensure_npx, find_npx  # noqa: F401  (find_npx and SetupError are part of this module's API)
+
 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.")
+         "before it shows anything. One-time setup: 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)
+IDLE_SECONDS = 600   # the Chrome connection is let go after this long without a read; the next read reconnects
+COOLDOWN_AFTER_429 = 600
 
 
 class Chrome:
@@ -50,6 +38,8 @@ class Chrome:
         self.tool = None
         self.last = 0.0
         self.lock = threading.Lock()
+        self.idle_timer = None
+        self.can_close_tab = False
 
     def start(self):
         if self.proc and self.proc.poll() is None:
@@ -57,30 +47,45 @@ class Chrome:
         cmd = list(self.command or [])
         env = dict(os.environ)
         if not cmd:
-            npx = find_npx()
-            if not npx:
-                raise SetupError(SETUP)
+            npx = ensure_npx()   # downloads the official Node.js once when none is installed; raises SetupError if it cannot
             cmd = [npx, "-y", "@playwright/mcp@latest", "--extension"]
             env["PATH"] = os.path.dirname(npx) + os.pathsep + env.get("PATH", "")
+        # Its own process group, ended as a tree; a Windows job or Linux's parent-death signal covers a crash (process.py).
+        if os.name == "nt":
+            process._windows_job()
+            group = {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
+        else:
+            process.reap_orphans()
+            group = {"preexec_fn": process._die_with_parent} if sys.platform.startswith("linux") else {"start_new_session": True}
         self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
-                                     text=True, encoding="utf-8", bufsize=1, env=env)
+                                     text=True, encoding="utf-8", bufsize=1, env=env, **group)
+        process._remember_child(self.proc)
         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)
+        self.can_close_tab = "browser_tabs" in names
         if not self.tool:
             raise SetupError("This Playwright MCP version cannot run a read; update it (npx -y @playwright/mcp@latest).")
+        try:
+            self.request("tools/call", {"name": self.tool, "arguments": {"code": process.NO_UNLOAD}}, 30)
+        except SetupError:
+            pass
 
     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()
+        mid, box, proc = self.n, {}, self.proc
+        try:
+            proc.stdin.write(json.dumps({"jsonrpc": "2.0", "id": mid, "method": method, "params": params}) + "\n")
+            proc.stdin.flush()
+        except (OSError, ValueError, AttributeError):
+            self.close(tidy=False)
+            raise SetupError("The Chrome connection had closed. Try again: ThreadFox Lite reconnects on the next read.")
 
         def read():
-            for line in self.proc.stdout:
+            for line in proc.stdout:
                 try:
                     msg = json.loads(line)
                 except ValueError:
@@ -88,11 +93,15 @@ class Chrome:
                 if msg.get("id") == mid:
                     box["msg"] = msg
                     return
+            box["eof"] = True   # the child exited: say so now instead of waiting out the timeout
         reader = threading.Thread(target=read, daemon=True)
         reader.start()
         reader.join(timeout or self.timeout)
         if "msg" not in box:
             self.close(tidy=False)
+            if box.get("eof"):
+                raise SetupError("The Chrome connection closed during the read (Chrome or the Playwright Extension disconnected). "
+                                 "Try again: ThreadFox Lite reconnects on the next read.")
             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"]:
@@ -109,15 +118,21 @@ class Chrome:
   }, %s);
   return JSON.stringify(out);
 }""" % json.dumps(path)
-        with self.lock:
-            wait = self.last + SPACING - time.time()
+        with self.lock, process.MachineLock() as machine:
+            shared = machine.state()
+            if time.time() < (shared.get("cooldown_until") or 0):
+                raise SetupError("Reddit asked to slow down; no Reddit reads until "
+                                 + time.strftime("%H:%M UTC", time.gmtime(shared["cooldown_until"])) + ".")
+            wait = max(self.last, shared.get("last_call") or 0) + SPACING - time.time()
             if wait > 0:
-                time.sleep(wait)
+                time.sleep(min(wait, SPACING))
             self.start()
             try:
                 result = self.request("tools/call", {"name": self.tool, "arguments": {"code": code}})
             finally:
                 self.last = time.time()
+                machine.update(last_call=self.last)
+                self.arm_idle()
         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()
@@ -126,22 +141,40 @@ class Chrome:
         if not m:
             raise SetupError("No answer came back from Chrome: " + text[:200])
         out = json.loads(json.loads(m.group(1)))
+        if out.get("status") == 429:
+            process._share_cooldown(time.time() + COOLDOWN_AFTER_429)   # every ThreadFox app on this computer waits
         return out.get("status"), out.get("body")
 
+    def arm_idle(self):
+        if self.idle_timer:
+            self.idle_timer.cancel()
+        self.idle_timer = threading.Timer(IDLE_SECONDS, self.idle_close)
+        self.idle_timer.daemon = True
+        self.idle_timer.start()
+
+    def idle_close(self):
+        if self.lock.acquire(blocking=False):   # never in the middle of a read
+            try:
+                self.close()
+            finally:
+                self.lock.release()
+
     def close(self, tidy=True):
-        """Close this session's tab in Chrome, then end the Playwright process."""
+        """Close this session's tab in Chrome (after a blank page, so nothing can hold it), then end the Playwright tree."""
+        if self.idle_timer:
+            self.idle_timer.cancel(); self.idle_timer = None
         if not self.proc:
             return
-        if tidy and self.proc.poll() is None:
+        if tidy and self.proc.poll() is None and self.tool:
             try:
-                self.request("tools/call", {"name": "browser_tabs", "arguments": {"action": "close"}}, timeout=10)
+                self.request("tools/call", {"name": self.tool, "arguments": {"code": process.LEAVE}}, timeout=10)
+                if self.can_close_tab:
+                    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
+        proc, self.proc = self.proc, None
+        process.kill_tree(proc)
+        process._forget_child(proc.pid)
 
 
 _chrome = None

threadfox_lite-0.2.5/src/threadfox_lite/node.py

@@ -0,0 +1,187 @@
+"""Node.js for Playwright MCP, without asking the user to install it.
+
+ThreadFox Lite's reads run Microsoft's Playwright MCP (`npx @playwright/mcp`), which needs Node.js 18+. When no usable
+Node.js is installed, the official Node.js LTS is downloaded into ~/.threadfox/runtime, checked against the SHA-256
+nodejs.org publishes (pinned below) and used from there. Nothing is installed system-wide. The full ThreadFox kit uses
+the same folder, so the two share one copy.
+"""
+import glob
+import hashlib
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import threading
+import urllib.request
+import zipfile
+
+
+class SetupError(RuntimeError):
+    """The browser route is not ready; the message says what to do."""
+
+
+# The official Node.js LTS, fetched only when no Node.js 18+ is installed. SHA-256 values are copied from
+# https://nodejs.org/dist/v24.21.0/SHASUMS256.txt; a download that does not match is deleted unrun.
+NODE_VERSION = '24.21.0'
+NODE_SHA256 = {
+    'darwin-arm64.tar.xz': '6239d4cf92d864487ec8cd3615038f7b67e7f58b77b21cd2f09ea9fbd68065fe',
+    'darwin-x64.tar.xz': '0ae5a24c24bb7d015cd816c5036b3f90f2945aa872fcf54e58da054753b3a299',
+    'linux-arm64.tar.xz': '6ad1325edbdb5649c379b75a237147a666c95d4f9ae8d340fef2d1575d289ad2',
+    'linux-x64.tar.xz': 'fd8e59d5a511510f6a298afb548f18c7d2b1be404d8b4a27d94fbe49f56cb2d6',
+    'darwin-arm64.tar.gz': 'bed7eea5325e1108f32ce5228ddd6a5f0f08a499ee42aa7442aea583702f6057',
+    'darwin-x64.tar.gz': '1462cb3b3046b815cf8ea436d3da450ec1a9f11dac7e5a46b0ada5305d7e8097',
+    'linux-arm64.tar.gz': '724282c3b43aec998aa9527380465b45d229e021b58035f5f4f63095eabfe5d5',
+    'linux-x64.tar.gz': '6e1db87ef58b8819e5d5402eff1536491b18edd8eb7bee5ef7897876e88dc5ff',
+    'win-arm64.zip': '8779b1bde1d39f8d420e3b57aa657b39891af434d3de44a919044cec06785921',
+    'win-x64.zip': '158f7685b44de51f6c0df1d153526cbcd3e1bc739a8dfc607721cef75de9e541',
+}
+NODE_BASE_URL = 'https://nodejs.org/dist'
+_node_lock = threading.Lock()
+
+
+def node_platform():
+    """('darwin'|'linux'|'win', 'arm64'|'x64'), with None for a platform nodejs.org has no build for."""
+    system = {'Darwin': 'darwin', 'Linux': 'linux', 'Windows': 'win'}.get(platform.system())
+    machine = platform.machine().lower()
+    arch = 'arm64' if machine in ('arm64', 'aarch64') else 'x64' if machine in ('x86_64', 'amd64', 'x64') else None
+    return system, arch
+
+
+def runtime_dirs():
+    """Where ThreadFox keeps its portable Node.js: THREADFOX_HOME or ~/.threadfox, shared with the full kit."""
+    home = os.environ.get('THREADFOX_HOME') or os.path.join(os.path.expanduser('~'), '.threadfox')
+    return [os.path.join(home, 'runtime')]
+
+
+def portable_npx():
+    system, arch = node_platform()
+    name = f'node-v{NODE_VERSION}-{system}-{arch}'
+    for base in runtime_dirs():
+        exe = os.path.join(base, name, 'npx.cmd') if system == 'win' else os.path.join(base, name, 'bin', 'npx')
+        if os.path.isfile(exe):
+            return exe
+    return None
+
+
+def find_npx():
+    """ThreadFox's own portable Node.js, then npx on PATH, then the usual Node.js install folders. Apps started from the
+    Dock or Start menu (Claude Desktop) often get a shorter PATH than a terminal, so a working install can be invisible to them."""
+    found = portable_npx() or 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)
+    candidates += sorted(glob.glob(os.path.join(home, '.fnm', 'node-versions', '*', 'installation', 'bin', 'npx')), reverse=True)
+    for base in filter(None, [os.environ.get('ProgramFiles'), os.environ.get('ProgramFiles(x86)'), 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)
+
+
+def node_major(npx):
+    """The major version of the node that sits next to this npx, or None when it cannot be asked."""
+    folder = os.path.dirname(npx)
+    node = next((c for c in (os.path.join(folder, 'node.exe'), os.path.join(folder, 'node')) if os.path.isfile(c)), None) or shutil.which('node')
+    try:
+        out = subprocess.run([node, '--version'], capture_output=True, text=True, timeout=15).stdout if node else ''
+    except (OSError, subprocess.SubprocessError):
+        return None
+    m = re.match(r'v(\d+)\.', out.strip())
+    return int(m.group(1)) if m else None
+
+
+def _download(url, dest):
+    """curl where it exists (every current macOS, Windows 10+ and most Linux): it uses the system's certificates, which some
+    Python builds on macOS cannot find. Python's own client otherwise."""
+    curl = shutil.which('curl')
+    if curl:
+        done = subprocess.run([curl, '-fsSL', '--retry', '2', '--connect-timeout', '20', '-o', dest, url],
+                              stdin=subprocess.DEVNULL, capture_output=True, text=True)
+        if done.returncode == 0:
+            return
+    with urllib.request.urlopen(url, timeout=60) as r, open(dest, 'wb') as f:
+        shutil.copyfileobj(r, f, 1 << 20)
+
+
+def _extract(archive, dest):
+    if archive.endswith('.zip'):
+        with zipfile.ZipFile(archive) as z:
+            z.extractall(dest)  # zipfile drops absolute paths and '..'
+        return
+    with tarfile.open(archive) as t:
+        if hasattr(tarfile, 'data_filter'):
+            t.extractall(dest, filter='data')
+            return
+        root = os.path.realpath(dest)
+        for m in t.getmembers():
+            target = os.path.realpath(os.path.join(dest, m.name))
+            link = os.path.realpath(os.path.join(os.path.dirname(target), m.linkname)) if m.issym() or m.islnk() else target
+            if not (target + os.sep).startswith(root + os.sep) or not (link + os.sep).startswith(root + os.sep) or m.isdev():
+                raise SetupError('The Node.js archive contains an unexpected path, so it was not unpacked.')
+        t.extractall(dest)
+
+
+def install_node():
+    """Download the official Node.js LTS into ThreadFox's runtime folder, check its SHA-256 before unpacking, and return its npx.
+    Nothing is installed system-wide and no installer runs; deleting the folder removes it."""
+    with _node_lock:
+        if portable_npx():
+            return portable_npx()
+        system, arch = node_platform()
+        ext = 'zip' if system == 'win' else 'tar.xz'
+        if ext == 'tar.xz':
+            try:
+                import lzma  # noqa: F401  (some Python builds leave it out; .tar.gz is twice the size but always readable)
+            except ImportError:
+                ext = 'tar.gz'
+        key = f'{system}-{arch}.{ext}'
+        if key not in NODE_SHA256:
+            raise SetupError(f'ThreadFox has no portable Node.js for {platform.system()} {platform.machine()}. '
+                               'Install Node.js 18+ from https://nodejs.org, then quit and reopen your AI app.')
+        name = f'node-v{NODE_VERSION}-{system}-{arch}'
+        runtime = runtime_dirs()[0]
+        os.makedirs(runtime, exist_ok=True)
+        work = tempfile.mkdtemp(prefix='.node-', dir=runtime)
+        try:
+            archive = os.path.join(work, name + '.' + ext)
+            try:
+                _download(f'{NODE_BASE_URL}/v{NODE_VERSION}/{name}.{ext}', archive)
+            except OSError as exc:
+                raise SetupError(f'Node.js could not be downloaded from nodejs.org ({exc}). Check the internet connection and try again, '
+                                   'or install Node.js 18+ from https://nodejs.org.')
+            digest = hashlib.sha256()
+            with open(archive, 'rb') as f:
+                for chunk in iter(lambda: f.read(1 << 20), b''):
+                    digest.update(chunk)
+            if digest.hexdigest() != NODE_SHA256[key]:
+                raise SetupError('The Node.js download did not match the checksum nodejs.org publishes, so it was deleted without '
+                                   'running. Try again, or install Node.js 18+ from https://nodejs.org.')
+            try:
+                _extract(archive, work)
+            except (tarfile.TarError, zipfile.BadZipFile, EOFError) as exc:
+                raise SetupError(f'The Node.js archive could not be unpacked safely ({exc}). Try again, or install Node.js 18+ from https://nodejs.org.')
+            final = os.path.join(runtime, name)
+            if os.path.isdir(final):
+                shutil.rmtree(final)
+            os.replace(os.path.join(work, name), final)
+        finally:
+            shutil.rmtree(work, ignore_errors=True)
+        exe = portable_npx()
+        if not exe:
+            raise SetupError('Node.js was unpacked but npx is missing. Install Node.js 18+ from https://nodejs.org.')
+        return exe
+
+
+def ensure_npx(install=True):
+    """An npx whose Node.js is 18 or newer: an installed one when it qualifies, otherwise ThreadFox's portable copy."""
+    exe = find_npx()
+    if exe and exe != portable_npx():
+        major = node_major(exe)
+        if major is None or major < 18:
+            exe = None  # Playwright MCP needs a Node.js 18+ that runs; an old or broken one is left alone and not used
+    if exe or not install:
+        return exe
+    return install_node()

threadfox_lite-0.2.5/src/threadfox_lite/process.py

@@ -0,0 +1,288 @@
+"""Staying light on the computer, shared with the full ThreadFox kit (same files in ~/.threadfox, so both coordinate).
+
+- One Reddit call at a time on this computer across every app running ThreadFox or ThreadFox Lite, with shared pacing
+  and a shared 429 cooldown (browser.lock and browser-state.json in THREADFOX_HOME or ~/.threadfox).
+- The Playwright child runs in its own process group and is ended as a tree. If ThreadFox Lite is killed first, a
+  Windows job ends the tree, Linux sends the child SIGTERM, and the next start reaps what is left.
+- The tab never registers "Leave site?", and goes to a blank page before it closes.
+Copied from the kit's threadfox_browser.py; keep the two in step.
+"""
+import json
+import os
+import subprocess
+import sys
+import time
+
+from .node import SetupError
+
+MACHINE_LOCK_WAIT = 120
+CLIENT = 'ThreadFox Lite'
+
+
+def threadfox_home():
+    return os.environ.get('THREADFOX_HOME') or os.path.join(os.path.expanduser('~'), '.threadfox')
+
+
+class MachineLock:
+    """One Reddit call at a time on this computer, across every app running ThreadFox. The state beside the lock carries
+    the pacing and any rate-limit cooldown, so two apps cannot together read faster than one, or ignore a 429 the other got."""
+
+    def __init__(self, wait=None):
+        self.wait = MACHINE_LOCK_WAIT if wait is None else wait
+        self.home = threadfox_home()
+        self.file = None
+
+    def _try(self):
+        if os.name == 'nt':
+            import msvcrt
+            self.file.seek(0)
+            msvcrt.locking(self.file.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+            fcntl.flock(self.file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+    def __enter__(self):
+        os.makedirs(self.home, exist_ok=True)
+        self.file = open(os.path.join(self.home, 'browser.lock'), 'a+')
+        if os.name == 'nt' and os.path.getsize(self.file.name) == 0:
+            self.file.write('0'); self.file.flush()
+        deadline = time.time() + self.wait
+        while True:
+            try:
+                self._try()
+                break
+            except OSError:
+                if time.time() >= deadline:
+                    holder = self.state().get('holder') or {}
+                    self.file.close(); self.file = None
+                    raise SetupError('Another app on this computer is using ThreadFox\'s Chrome connection'
+                                       + (f" ({holder.get('client')}, since {holder.get('since')})" if holder.get('client') else '')
+                                       + f'. ThreadFox waited {self.wait} seconds for its turn; try again in a moment.')
+                time.sleep(0.25)
+        self.update(holder={'client': CLIENT, 'pid': os.getpid(), 'since': time.strftime('%H:%M:%S')})
+        return self
+
+    def __exit__(self, *exc):
+        try:
+            self.update(holder=None)
+            if os.name == 'nt':
+                import msvcrt
+                self.file.seek(0)
+                msvcrt.locking(self.file.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(self.file, fcntl.LOCK_UN)
+        finally:
+            self.file.close(); self.file = None
+
+    def state(self):
+        try:
+            with open(os.path.join(self.home, 'browser-state.json'), encoding='utf-8') as f:
+                return json.load(f)
+        except (OSError, ValueError):
+            return {}
+
+    def update(self, **changes):
+        data = dict(self.state(), **changes)
+        os.makedirs(self.home, exist_ok=True)   # a fresh computer has no ThreadFox folder until the first write
+        path = os.path.join(self.home, 'browser-state.json')
+        with open(path + '.tmp', 'w', encoding='utf-8') as f:
+            json.dump(data, f)
+        os.replace(path + '.tmp', path)
+
+
+def _share_cooldown(until):
+    """Tell every app on this computer about a 429, so none of them calls Reddit before it ends."""
+    try:
+        MachineLock().update(cooldown_until=until)
+    except OSError:
+        pass
+
+
+_JOB = None
+JOB_STATUS = 'not tried'   # threadfox_doctor and the tests read why the job did or did not attach
+
+
+def _windows_job():
+    """Put this ThreadFox process in a Windows job that kills everything in it when its last handle closes. Children
+    inherit the job, so when ThreadFox exits in any way (the AI app closing it, a crash, Task Manager) Windows ends the
+    Playwright child, Node.js and anything they started. Best effort: without it, close() still ends the tree."""
+    global _JOB, JOB_STATUS
+    if os.name != 'nt' or _JOB is not None:
+        return
+    try:
+        import ctypes
+        from ctypes import wintypes
+        k32 = ctypes.WinDLL('kernel32', use_last_error=True)
+
+        class IO(ctypes.Structure):
+            _fields_ = [(n, ctypes.c_ulonglong) for n in ('r', 'w', 'o', 'rb', 'wb', 'ob')]
+
+        class BASIC(ctypes.Structure):
+            _fields_ = [('PerProcessUserTimeLimit', ctypes.c_longlong), ('PerJobUserTimeLimit', ctypes.c_longlong),
+                        ('LimitFlags', wintypes.DWORD), ('MinimumWorkingSetSize', ctypes.c_size_t),
+                        ('MaximumWorkingSetSize', ctypes.c_size_t), ('ActiveProcessLimit', wintypes.DWORD),
+                        ('Affinity', ctypes.c_size_t), ('PriorityClass', wintypes.DWORD), ('SchedulingClass', wintypes.DWORD)]
+
+        class EXTENDED(ctypes.Structure):
+            _fields_ = [('BasicLimitInformation', BASIC), ('IoInfo', IO), ('ProcessMemoryLimit', ctypes.c_size_t),
+                        ('JobMemoryLimit', ctypes.c_size_t), ('PeakProcessMemoryUsed', ctypes.c_size_t),
+                        ('PeakJobMemoryUsed', ctypes.c_size_t)]
+
+        # Explicit signatures: without them ctypes cannot pass the current-process pseudo-handle (-1) and the call fails.
+        k32.CreateJobObjectW.argtypes = [ctypes.c_void_p, wintypes.LPCWSTR]
+        k32.CreateJobObjectW.restype = wintypes.HANDLE
+        k32.SetInformationJobObject.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD]
+        k32.SetInformationJobObject.restype = wintypes.BOOL
+        k32.GetCurrentProcess.argtypes = []
+        k32.GetCurrentProcess.restype = wintypes.HANDLE
+        k32.AssignProcessToJobObject.argtypes = [wintypes.HANDLE, wintypes.HANDLE]
+        k32.AssignProcessToJobObject.restype = wintypes.BOOL
+        job = k32.CreateJobObjectW(None, None)
+        if not job:
+            JOB_STATUS = f'CreateJobObject failed ({ctypes.get_last_error()})'
+            return
+        info = EXTENDED()
+        info.BasicLimitInformation.LimitFlags = 0x2000 | 0x800   # KILL_ON_JOB_CLOSE | BREAKAWAY_OK
+        if not k32.SetInformationJobObject(job, 9, ctypes.byref(info), ctypes.sizeof(info)):
+            JOB_STATUS = f'SetInformationJobObject failed ({ctypes.get_last_error()})'
+            return
+        if not k32.AssignProcessToJobObject(job, k32.GetCurrentProcess()):
+            JOB_STATUS = f'AssignProcessToJobObject failed ({ctypes.get_last_error()})'
+            return
+        _JOB = job   # kept open for this process's lifetime; it closes, and the job ends, when ThreadFox does
+        JOB_STATUS = 'attached'
+    except Exception as exc:
+        JOB_STATUS = f'unavailable ({exc})'
+
+
+def _die_with_parent():
+    """Linux: the Playwright child gets SIGTERM if ThreadFox is killed without a chance to close it."""
+    os.setsid()
+    try:
+        import ctypes, signal
+        ctypes.CDLL('libc.so.6', use_errno=True).prctl(1, signal.SIGTERM)   # PR_SET_PDEATHSIG
+    except Exception:
+        pass
+
+
+def _group_members(pgid):
+    try:
+        out = subprocess.run(['ps', '-A', '-o', 'pid=,pgid='], capture_output=True, text=True, timeout=5).stdout
+    except (OSError, subprocess.SubprocessError):
+        return []
+    rows = [line.split() for line in out.splitlines() if len(line.split()) == 2]
+    return [int(pid) for pid, group in rows if group.isdigit() and int(group) == pgid]
+
+
+def reap_orphans():
+    """End Playwright processes left by a ThreadFox that died without closing them (POSIX; Windows' job does this).
+    Each child ThreadFox starts leads its own process group. When that ThreadFox is gone: a leader still running with
+    ThreadFox's command is ended with its group, and a group whose leader already exited (Linux ends the leader with
+    its parent) but still has members is those members' group, since only that leader could have created it.
+    Records older than a day are dropped unused."""
+    if os.name == 'nt':
+        return
+    import signal
+    state = MachineLock().state()
+    kept = []
+    for entry in state.get('children') or []:
+        try:
+            os.kill(entry['parent'], 0)
+            kept.append(entry)          # its ThreadFox is still running
+            continue
+        except OSError:
+            pass
+        if time.time() - (entry.get('at') or 0) > 86400:
+            continue
+        pid = entry['pid']
+        try:
+            os.kill(pid, 0)
+            leader_alive = True
+        except OSError:
+            leader_alive = False
+        if leader_alive:
+            try:
+                command = subprocess.run(['ps', '-o', 'command=', '-p', str(pid)], capture_output=True, text=True, timeout=5).stdout
+            except (OSError, subprocess.SubprocessError):
+                command = ''
+            ours = [t for t in entry.get('cmd') or [] if t] or ['playwright', 'npx']
+            if not any(t.lower() in command.lower() for t in ours):
+                continue                # the pid now belongs to something else: leave it
+        elif not _group_members(pid):
+            continue                    # nothing left of that group
+        try:
+            os.killpg(pid, signal.SIGTERM)
+        except OSError:
+            pass
+    try:
+        MachineLock().update(children=kept)
+    except OSError:
+        pass
+
+
+def _remember_child(proc):
+    try:
+        state = MachineLock().state()
+        children = [c for c in state.get('children') or [] if c.get('pid') != proc.pid][-20:]
+        tokens = [os.path.basename(str(x)) for x in (proc.args[:2] if isinstance(proc.args, list) else [proc.args])]
+        MachineLock().update(children=children + [{'pid': proc.pid, 'parent': os.getpid(), 'at': int(time.time()), 'cmd': tokens}])
+    except OSError:
+        pass
+
+
+def _forget_child(pid):
+    try:
+        state = MachineLock().state()
+        MachineLock().update(children=[c for c in state.get('children') or [] if c.get('pid') != pid])
+    except OSError:
+        pass
+
+
+def busy_holder():
+    """The app holding the Chrome connection right now, or None (threadfox_doctor reports it)."""
+    try:
+        with MachineLock(wait=0):
+            return None
+    except SetupError:
+        return MachineLock().state().get('holder') or {'client': 'another app'}
+
+
+def kill_tree(proc):
+    """End the Playwright child and everything it started. On Windows npx.cmd starts node, which starts Playwright MCP:
+    killing only the first left Node.js processes running in the background after every session."""
+    if proc is None or proc.poll() is not None:
+        return
+    try:
+        if os.name == 'nt':
+            subprocess.run(['taskkill', '/PID', str(proc.pid), '/T', '/F'], capture_output=True, timeout=15)
+        else:
+            import signal
+            os.killpg(proc.pid, signal.SIGTERM)
+            try:
+                proc.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                os.killpg(proc.pid, signal.SIGKILL)
+    except (OSError, subprocess.SubprocessError):
+        pass
+    try:
+        proc.kill()
+        proc.wait(timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        pass
+
+
+# ThreadFox's own tab never registers "Leave site?": an unsent draft would otherwise hold the tab with a modal dialog
+# that blocks navigation and closing. Reddit's own checks are untouched.
+NO_UNLOAD = """async (page) => {
+  await page.addInitScript(() => {
+    const add = EventTarget.prototype.addEventListener;
+    EventTarget.prototype.addEventListener = function (type, fn, opts) { if (type === 'beforeunload') return; return add.call(this, type, fn, opts); };
+    Object.defineProperty(window, 'onbeforeunload', {configurable: true, get() { return null; }, set() {}});
+  });
+  return JSON.stringify({ok: true});
+}"""
+LEAVE = """async (page) => {
+  await page.goto('about:blank').catch(() => {});
+  return JSON.stringify({left: page.url()});
+}"""

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/src/threadfox_lite/server.py

@@ -5,17 +5,19 @@ which tells a paying customer how to open the full ThreadFox kit (posting from y
 the outcome ledger and the course). The full kit is sold at https://threadfox.vip and on MCP Marketplace.
 """
 import os
+import threading
 
 from mcp.server.fastmcp import FastMCP
 
-from . import reddit
+from . import node, reddit
 
 from . import __version__
 
 mcp = FastMCP("threadfox-lite", instructions=(
     "Free, read-only Reddit tools. find_communities and subreddit_rules before writing a post, account_check before posting "
     "from an account, post_status at 1, 6 and 24 hours. Every read runs in the user's own signed-in Chrome; if a tool returns "
-    "setup steps (Node.js and the Playwright Extension), relay them plainly and stop. Nothing here posts or changes anything."))
+    "setup steps (the Playwright Extension in Chrome), relay them plainly and stop. Node.js is fetched automatically when missing. "
+    "Nothing here posts or changes anything."))
 mcp._mcp_server.version = __version__   # report ThreadFox Lite's version, not the MCP library's
 
 
@@ -65,7 +67,17 @@ def threadfox_full_kit() -> dict:
             "get_it": "https://threadfox.vip ($49 once, 30-day refund) or ThreadFox on MCP Marketplace"}
 
 
+def _prefetch_node():
+    """Fetch Node.js in the background at start when none is usable, so the first read does not wait for it."""
+    try:
+        if not os.environ.get("THREADFOX_LITE_BROWSER_CMD"):
+            node.ensure_npx()
+    except Exception:
+        pass   # the first read reports the reason
+
+
 def main():
+    threading.Thread(target=_prefetch_node, daemon=True).start()
     mcp.run()
 
 

threadfox_lite-0.2.5/tests/test_node.py

@@ -0,0 +1,57 @@
+"""No Node.js installed: the official Node.js LTS is downloaded once, checked against its pinned SHA-256, and used."""
+import hashlib, io, os, sys, tarfile, tempfile, unittest
+from pathlib import Path
+from unittest.mock import patch
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from threadfox_lite import node
+
+NAME = f"node-v{node.NODE_VERSION}-linux-x64"
+
+
+class PortableNode(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(); root = Path(self.tmp.name)
+        self.home = root / "home"; self.dist = root / "dist" / f"v{node.NODE_VERSION}"; self.dist.mkdir(parents=True)
+        for p in (patch.dict(os.environ, {"THREADFOX_HOME": str(self.home)}), patch.object(node, "NODE_BASE_URL", (root / "dist").as_uri()),
+                  patch.object(node, "node_platform", return_value=("linux", "x64"))):
+            p.start(); self.addCleanup(p.stop)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def publish(self, members):
+        archive = self.dist / f"{NAME}.tar.xz"
+        with tarfile.open(archive, "w:xz") as tar:
+            for name, data in members:
+                info = tarfile.TarInfo(name); info.size = len(data); info.mode = 0o755
+                tar.addfile(info, io.BytesIO(data))
+        return hashlib.sha256(archive.read_bytes()).hexdigest()
+
+    def test_downloads_checks_and_unpacks_once(self):
+        digest = self.publish([(f"{NAME}/bin/node", b"#!/bin/sh\n"), (f"{NAME}/bin/npx", b"#!/bin/sh\n")])
+        with patch.dict(node.NODE_SHA256, {"linux-x64.tar.xz": digest}):
+            npx = node.install_node()
+            self.assertEqual(npx, str(self.home / "runtime" / NAME / "bin" / "npx"))
+            (self.dist / f"{NAME}.tar.xz").unlink()
+            self.assertEqual(node.install_node(), npx)
+        self.assertEqual(os.listdir(self.home / "runtime"), [NAME])
+
+    def test_a_mismatched_download_is_deleted_unrun(self):
+        self.publish([(f"{NAME}/bin/npx", b"tampered")])
+        with patch.dict(node.NODE_SHA256, {"linux-x64.tar.xz": "0" * 64}):
+            with self.assertRaisesRegex(node.SetupError, "checksum"):
+                node.install_node()
+        self.assertEqual(os.listdir(self.home / "runtime"), [])
+
+    def test_an_old_or_broken_installed_node_is_not_used(self):
+        with patch.object(node, "find_npx", return_value="/usr/bin/npx"), patch.object(node, "install_node", return_value="PORTABLE"):
+            with patch.object(node, "node_major", return_value=16):
+                self.assertEqual(node.ensure_npx(), "PORTABLE")
+            with patch.object(node, "node_major", return_value=None):
+                self.assertEqual(node.ensure_npx(), "PORTABLE")
+            with patch.object(node, "node_major", return_value=22):
+                self.assertEqual(node.ensure_npx(), "/usr/bin/npx")
+
+
+if __name__ == "__main__":
+    unittest.main()

threadfox_lite-0.2.5/tests/test_process.py

@@ -0,0 +1,92 @@
+"""ThreadFox Lite stays light on the computer and coordinates with the full kit through the same files."""
+import json, os, subprocess, sys, tempfile, textwrap, time, unittest
+from pathlib import Path
+from unittest.mock import patch
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+from threadfox_lite import browser, process
+
+FAKE = textwrap.dedent('''
+    import json, subprocess, sys
+    mode = sys.argv[1]
+    if mode == 'grandchild':
+        kid = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)'])
+        open(sys.argv[2], 'w').write(str(kid.pid))
+    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 mode == 'dies' and 'threadfox-die' in json.dumps(msg): sys.exit(0)
+        elif mode == 'limited' and 'fetch(path' in json.dumps(msg):
+            out = {'content': [{'type': 'text', 'text': '### Result\\n' + json.dumps(json.dumps({'status': 429, 'body': None})) + '\\n'}]}
+        else: out = {'content': [{'type': 'text', 'text': '### Result\\n' + json.dumps(json.dumps({'status': 200, 'body': {'ok': 1}})) + '\\n'}]}
+        sys.stdout.write(json.dumps({'jsonrpc': '2.0', 'id': msg['id'], 'result': out}) + '\\n'); sys.stdout.flush()
+''')
+
+
+class Light(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(); self.root = Path(self.tmp.name)
+        for p in (patch.dict(os.environ, {"THREADFOX_HOME": str(self.root / "home")}), patch.object(browser, "SPACING", 0)):
+            p.start(); self.addCleanup(p.stop)
+        (self.root / "fake.py").write_text(FAKE)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def chrome(self, *args):
+        return browser.Chrome([sys.executable, str(self.root / "fake.py"), *args], timeout=20)
+
+    def test_it_uses_the_same_lock_and_state_files_as_the_full_kit(self):
+        lock = process.MachineLock()
+        self.assertEqual(Path(lock.home), self.root / "home")
+        with lock:
+            pass
+        self.assertTrue((self.root / "home" / "browser.lock").exists())
+        self.assertTrue((self.root / "home" / "browser-state.json").exists())
+
+    def test_a_429_is_shared_with_every_threadfox_app_on_the_computer(self):
+        c = self.chrome("limited")
+        self.assertEqual(c.get("/r/x/about.json")[0], 429)
+        self.assertGreater(process.MachineLock().state()["cooldown_until"], time.time() + 500)
+        with self.assertRaisesRegex(browser.SetupError, "slow down"):
+            self.chrome("ok").get("/r/x/about.json")
+        c.close()
+
+    def test_a_dead_browser_is_reported_at_once_and_the_next_read_reconnects(self):
+        c = self.chrome("dies")
+        started = time.time()
+        c.start()
+        with self.assertRaisesRegex(browser.SetupError, "closed during the read"):
+            c.request("tools/call", {"name": "x", "arguments": {"code": "threadfox-die"}})
+        self.assertLess(time.time() - started, 5)
+        c.command = [sys.executable, str(self.root / "fake.py"), "ok"]
+        self.assertEqual(c.get("/r/x/about.json"), (200, {"ok": 1}))
+        c.close()
+
+    @unittest.skipIf(os.name == "nt", "POSIX process groups; Windows uses a job object")
+    def test_closing_ends_the_whole_process_tree(self):
+        pidfile = self.root / "gc.pid"
+        c = self.chrome("grandchild", str(pidfile))
+        c.get("/r/x/about.json")
+        grandchild = int(pidfile.read_text())
+        c.close()
+        for _ in range(50):
+            try:
+                os.kill(grandchild, 0); time.sleep(0.1)
+            except OSError:
+                break
+        else:
+            self.fail("the grandchild outlived close()")
+
+    def test_an_idle_connection_is_let_go(self):
+        with patch.object(browser, "IDLE_SECONDS", 0.3):
+            c = self.chrome("ok")
+            c.get("/r/x/about.json")
+            time.sleep(1.0)
+            self.assertIsNone(c.proc)
+            c.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/tests/test_reddit.py

@@ -103,7 +103,7 @@ class Setup(unittest.TestCase):
             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"])
+            self.assertIn("Playwright Extension", r["error"]); self.assertNotIn("install Node.js", 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."""

{threadfox_lite-0.2.3 → threadfox_lite-0.2.5}/uv.lock

@@ -859,7 +859,7 @@ wheels = [
 
 [[package]]
 name = "threadfox-lite"
-version = "0.2.3"
+version = "0.2.5"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },