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

{threadfox_lite-0.2.4 → 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.4",
+      "version": "0.2.5",
       "category": "marketing",
       "homepage": "https://threadfox.vip"
     }

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

@@ -1,6 +1,6 @@
 {
   "name": "threadfox-lite",
-  "version": "0.2.4",
+  "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.4 → threadfox_lite-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: threadfox-lite
-Version: 0.2.4
+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: 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). 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.4 → 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: 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). 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.4 → threadfox_lite-0.2.5}/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.4",
   "name": "threadfox-lite",
   "display_name": "ThreadFox Lite",
-  "version": "0.2.4",
+  "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 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": {

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

@@ -1,6 +1,6 @@
 [project]
 name = "threadfox-lite"
-version = "0.2.4"
+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.4 → 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.4",
+  "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.4",
+      "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.4/threadfox-lite-0.2.4.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.4 → 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.4"
+__version__ = "0.2.5"

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

@@ -11,9 +11,11 @@ import json
 import os
 import re
 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"
@@ -21,6 +23,8 @@ SETUP = ("ThreadFox Lite reads Reddit through your own signed-in Chrome, because
          "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
+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:
@@ -34,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:
@@ -44,25 +50,42 @@ class Chrome:
             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:
@@ -70,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"]:
@@ -91,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()
@@ -108,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/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.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.4 → threadfox_lite-0.2.5}/uv.lock

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