@m13v/s4l 1.7.4-rc.38 → 1.7.4-rc.39

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.4-rc.38",
-  "installedAt": "2026-07-14T01:01:14.735Z"
+  "version": "1.7.4-rc.39",
+  "installedAt": "2026-07-14T01:27:42.097Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.4-rc.38",
+  "version": "1.7.4-rc.39",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.4-rc.38",
+  "version": "1.7.4-rc.39",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.4-rc.38",
+  "version": "1.7.4-rc.39",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js",

package/scripts/stall_guard.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Shared zero-progress deadline for browser-touching pipeline steps.
+
+Any step that relays CDP to the harness Chrome (scan queries, thread media
+capture, ...) can hang FOREVER against a half-wedged browser or a dead
+renderer: the call never returns, the step holds the browser lock, and the
+cycle-entry health checks that could heal Chrome can't run because the next
+cycle can't start. 2026-07-13: a scan hung 23 min at zero queries; the same
+night media capture hung 34+ min at candidate 24/92 and only the watchdog's
+90-min lock-liveness net was ever going to reap it.
+
+One implementation, used by every step (twitter_scan.py Phase-1 queries,
+twitter_browser.py media capture). Usage:
+
+    from stall_guard import stall_guard
+    with stall_guard("thread_media", url):   # default deadline 240s
+        <one bounded unit of browser work>
+
+If the guarded block does not finish inside the deadline the guard:
+  1. prints a loud machine-greppable marker to stderr
+     ([stall_guard] STALL_ABORT step=<step> ...)
+  2. stamps the port's wedge strike file, so the next cycle's two-strike
+     gate in skill/lib/twitter-backend.sh converges to a kill+relaunch if
+     Chrome is genuinely sick
+  3. hard-exits the process with EX_TEMPFAIL (75) so the cycle fails fast
+     and releases the browser lock + cycle slot.
+
+A completed block cancels its timer; a healthy pipeline never notices the
+guard exists. Deadline override: S4L_BROWSER_OP_DEADLINE_S (seconds).
+"""
+from __future__ import annotations
+
+import contextlib
+import os
+import pathlib
+import sys
+import threading
+
+DEFAULT_DEADLINE_S = float(os.environ.get("S4L_BROWSER_OP_DEADLINE_S", "240"))
+
+
+def _strike_file(port: int) -> str:
+    # Must match the two-strike gate in skill/lib/twitter-backend.sh.
+    return f"/tmp/s4l_cdp_wedge_strike_{port}"
+
+
+@contextlib.contextmanager
+def stall_guard(step: str, detail: str = "", deadline_s: float | None = None, port: int = 9555):
+    limit = DEFAULT_DEADLINE_S if deadline_s is None else float(deadline_s)
+
+    def _fire():
+        sys.stderr.write(
+            f"[stall_guard] STALL_ABORT step={step} detail={detail!r} "
+            f"deadline={limit:.0f}s — browser call hung (wedged Chrome or dead "
+            "renderer); stamping wedge strike and aborting so the lock frees\n"
+        )
+        sys.stderr.flush()
+        try:
+            pathlib.Path(_strike_file(port)).touch()
+        except OSError:
+            pass
+        os._exit(75)  # EX_TEMPFAIL
+
+    t = threading.Timer(limit, _fire)
+    t.daemon = True
+    t.start()
+    try:
+        yield
+    finally:
+        t.cancel()

package/scripts/twitter_browser.py

@@ -2732,6 +2732,19 @@ def _anchor_repost_from_tweets(tweets, anchor_tweet_id):
 
 
 def scrape_thread_media(thread_url, scroll_count=1):
+    """Deadline wrapper: media capture relays CDP to the harness Chrome, and
+    against a half-wedged browser or dead renderer a single evaluate can hang
+    FOREVER (2026-07-13: hung 34+ min at candidate 24/92 holding the browser
+    lock; only the watchdog's 90-min lock-liveness net would have reaped it).
+    stall_guard aborts the process fast, stamps the wedge strike, and lets the
+    cycle-entry heal chain converge. Shared implementation — see
+    scripts/stall_guard.py; do NOT re-implement per step."""
+    from stall_guard import stall_guard
+    with stall_guard("thread_media", thread_url):
+        return _scrape_thread_media_inner(thread_url, scroll_count)
+
+
+def _scrape_thread_media_inner(thread_url, scroll_count=1):
     """Navigate to a tweet's permalink and return the media of the anchor tweet.
 
     Deterministic, model-free media capture for the MAIN posting cycle: the

package/scripts/twitter_scan.py

@@ -56,7 +56,6 @@ import os
 import pathlib
 import re
 import sys
-import threading
 import time
 import urllib.parse
 
@@ -247,38 +246,13 @@ def _navigate(url: str) -> None:
         new_tab(url)
 
 
-# Per-query stall guard (2026-07-13). The daemon helpers (goto_url/js) relay
-# CDP through the harness daemon; against a half-wedged Chrome those calls can
-# hang far past any useful budget, and one stuck query froze a Phase 1 scan at
-# "scan 0 · 23m" while holding the browser lock — the entry wedge check can't
-# help because the NEXT cycle can't start until this one dies. Self-heal from
-# inside instead: if a single scan() call exceeds the deadline, print a loud
-# marker, stamp the wedge strike file (so the next cycle's two-strike gate in
-# twitter-backend.sh converges to a kill+relaunch if Chrome is still sick),
-# and hard-exit the scan process so the cycle fails fast and releases the
-# lock. A healthy query completes in well under a minute; 240s is generous.
-_SCAN_QUERY_DEADLINE_S = float(os.environ.get("S4L_SCAN_QUERY_DEADLINE_S", "240"))
-_WEDGE_STRIKE_FILE = "/tmp/s4l_cdp_wedge_strike_9555"  # matches twitter-backend.sh
-
-
-def _arm_stall_guard(query: str):
-    def _fire():
-        sys.stderr.write(
-            f"[twitter_scan] SCAN_STALL_ABORT query={query!r} "
-            f"deadline={_SCAN_QUERY_DEADLINE_S:.0f}s — CDP call hung (wedged "
-            "Chrome); stamping wedge strike and aborting the scan process\n"
-        )
-        sys.stderr.flush()
-        try:
-            pathlib.Path(_WEDGE_STRIKE_FILE).touch()
-        except OSError:
-            pass
-        os._exit(75)  # EX_TEMPFAIL: cycle fails fast, lock + slot free up
+# Per-query stall guard: shared implementation (scripts/stall_guard.py) used
+# by every browser-touching pipeline step — do NOT re-implement per step.
+# S4L_SCAN_QUERY_DEADLINE_S kept as a scan-specific override for continuity
+# with rc.36-38; unset, the shared default applies.
+from stall_guard import stall_guard  # noqa: E402
 
-    t = threading.Timer(_SCAN_QUERY_DEADLINE_S, _fire)
-    t.daemon = True
-    t.start()
-    return t
+_SCAN_DEADLINE_OVERRIDE = os.environ.get("S4L_SCAN_QUERY_DEADLINE_S")
 
 
 def scan(
@@ -293,11 +267,12 @@ def scan(
     ###TWEETS_BEGIN###/###TWEETS_END### sentinels for the scan model to relay
     into StructuredOutput; also returns the kept list so direct callers (tests,
     future shell-driven invocations) can consume it without parsing stdout."""
-    _stall_guard = _arm_stall_guard(query)
-    try:
+    with stall_guard(
+        "scan_query",
+        query,
+        deadline_s=float(_SCAN_DEADLINE_OVERRIDE) if _SCAN_DEADLINE_OVERRIDE else None,
+    ):
         return _scan_inner(query, project, search_topic, freshness_hours, skip_ids, settle_seconds)
-    finally:
-        _stall_guard.cancel()
 
 
 def _scan_inner(

package/skill/lib/browser-launch.sh

@@ -0,0 +1,54 @@
+#!/bin/bash
+# browser-launch.sh — the ONE way any backend spawns a harness Chrome.
+#
+# Consolidates what twitter-backend.sh and linkedin-backend.sh grew as
+# hand-rolled near-duplicates on 2026-07-13 (and reddit-backend.sh never got
+# at all). Source this from a backend lib and call:
+#
+#     launch_harness_chrome "$_chrome_bin" "$_prof_dir" <chrome arg>...
+#
+# What every launch gets, uniformly:
+#   1. CLEAN-EXIT STAMP: mark the profile's last exit as clean first, so a
+#      SIGKILLed Chrome (wedge heal, stall abort) doesn't session-restore a
+#      crashed "Aw, Snap" corpse tab on relaunch.
+#   2. NO FOCUS STEAL (macOS + .app bundle): `open -n -g` launches a NEW
+#      instance (-n: the user's personal Chrome may already be running;
+#      without it LaunchServices pokes that instance and drops our --args)
+#      without activation (-g). A directly-exec'd Chrome always activates
+#      itself and planted a window over the user's work on every relaunch.
+#      LaunchServices also parents the process outside the caller's launchd
+#      job process group — independent cover for the pgroup-reaping bug.
+#      (Tested alternatives that DON'T work: `-j` — Chrome unhides and
+#      activates itself anyway; `--no-startup-window` — the activation just
+#      moves to first-tab creation.)
+#   3. DETACHED FALLBACK (Linux / bare chromium binaries): direct exec in a
+#      NEW SESSION via os.setsid, so a transient launchd job's exit can't
+#      SIGKILL Chrome with the job's process group (2026-07-12 root cause of
+#      the kill-relaunch-foreground loop).
+launch_harness_chrome() {
+    local _bl_chrome_bin="$1"; shift
+    local _bl_prof_dir="$1"; shift
+    "${S4L_PYTHON:-python3}" -c 'import json, os, sys
+p = os.path.join(sys.argv[1], "Default", "Preferences")
+try:
+    d = json.load(open(p))
+except Exception:
+    raise SystemExit(0)
+prof = d.setdefault("profile", {})
+prof["exit_type"] = "Normal"
+prof["exited_cleanly"] = True
+json.dump(d, open(p, "w"))' "$_bl_prof_dir" 2>/dev/null || true
+    local _bl_app_bundle=""
+    case "$_bl_chrome_bin" in
+        *.app/Contents/MacOS/*) _bl_app_bundle="${_bl_chrome_bin%%/Contents/MacOS/*}" ;;
+    esac
+    if [ "$(uname -s)" = "Darwin" ] && [ -n "$_bl_app_bundle" ] && [ -d "$_bl_app_bundle" ]; then
+        open -n -g -a "$_bl_app_bundle" --args "$@" >/dev/null 2>&1 || true
+    else
+        "${S4L_PYTHON:-python3}" -c 'import os,sys
+os.setsid()
+os.execv(sys.argv[1], sys.argv[1:])' \
+            "$_bl_chrome_bin" "$@" >/dev/null 2>&1 &
+        disown
+    fi
+}

package/skill/lib/linkedin-backend.sh

@@ -333,52 +333,21 @@ ensure_linkedin_browser_for_backend() {
         # The occlusion/backgrounding flags matter: the window sits offscreen,
         # and without them Chrome stops laying out SPA-rendered content, so
         # every element measures 0x0 and clicks become impossible (2026-07-03).
-        # Mark the profile's last exit as clean BEFORE launching, so a
-        # SIGKILLed Chrome doesn't session-restore a crashed "Aw, Snap" tab on
-        # relaunch (same fix + rationale as twitter-backend.sh, 2026-07-13).
-        "${S4L_PYTHON:-python3}" -c 'import json, os, sys
-p = os.path.join(sys.argv[1], "Default", "Preferences")
-try:
-    d = json.load(open(p))
-except Exception:
-    raise SystemExit(0)
-prof = d.setdefault("profile", {})
-prof["exit_type"] = "Normal"
-prof["exited_cleanly"] = True
-json.dump(d, open(p, "w"))' "$_prof_dir" 2>/dev/null || true
-        # Launch flags shared by both spawn paths below.
-        local _li_launch_args=(
-            --remote-debugging-port=9556
-            --user-data-dir="$HOME/.claude/browser-profiles/browser-harness-linkedin"
-            --no-first-run --no-default-browser-check
-            --disable-features=ChromeWhatsNewUI
-            --disable-backgrounding-occluded-windows
-            --disable-renderer-backgrounding
-            --disable-background-timer-throttling
-            "${_extra[@]}"
+        # Spawn via the SHARED launcher (skill/lib/browser-launch.sh) — see
+        # that file for the clean-exit stamp + no-focus-steal + detach
+        # rationale. Do NOT hand-roll launch logic per backend.
+        # shellcheck disable=SC1091
+        source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/browser-launch.sh"
+        launch_harness_chrome "$_chrome_bin" "$_prof_dir" \
+            --remote-debugging-port=9556 \
+            --user-data-dir="$HOME/.claude/browser-profiles/browser-harness-linkedin" \
+            --no-first-run --no-default-browser-check \
+            --disable-features=ChromeWhatsNewUI \
+            --disable-backgrounding-occluded-windows \
+            --disable-renderer-backgrounding \
+            --disable-background-timer-throttling \
+            "${_extra[@]}" \
             about:blank
-        )
-        # macOS + .app-bundled Chrome: `open -n -g` launches a NEW instance
-        # WITHOUT stealing the user's focus (a directly-exec'd Chrome always
-        # activates itself), and LaunchServices parents it outside this launchd
-        # job's process group. Same fix + rationale as twitter-backend.sh
-        # (2026-07-13). Fallback: direct exec in a new session — os.setsid so
-        # Chrome escapes the job's process group; launchd SIGKILLs a transient
-        # job's whole pgroup when the shell exits, and `disown` does not change
-        # the pgid (2026-07-12).
-        local _li_app_bundle=""
-        case "$_chrome_bin" in
-            *.app/Contents/MacOS/*) _li_app_bundle="${_chrome_bin%%/Contents/MacOS/*}" ;;
-        esac
-        if [ "$(uname -s)" = "Darwin" ] && [ -n "$_li_app_bundle" ] && [ -d "$_li_app_bundle" ]; then
-            open -n -g -a "$_li_app_bundle" --args "${_li_launch_args[@]}" >/dev/null 2>&1 || true
-        else
-            "${S4L_PYTHON:-python3}" -c 'import os,sys
-os.setsid()
-os.execv(sys.argv[1], sys.argv[1:])' \
-                "$_chrome_bin" "${_li_launch_args[@]}" >/dev/null 2>&1 &
-            disown
-        fi
         for _i in 1 2 3 4 5 6 7 8 9 10 11 12; do
             curl -sf --max-time 2 -o /dev/null http://127.0.0.1:9556/json/version 2>/dev/null && break
             sleep 1

package/skill/lib/reddit-backend.sh

@@ -203,14 +203,20 @@ ensure_reddit_browser_for_backend() {
             [ -n "$_stale_pids" ] && { kill -9 $_stale_pids 2>/dev/null || true; sleep 1; }
             rm -f "$_prof_dir/SingletonLock" "$_prof_dir/SingletonSocket" "$_prof_dir/SingletonCookie" 2>/dev/null || true
         fi
-        "$_chrome_bin" \
+        # Spawn via the SHARED launcher (skill/lib/browser-launch.sh): clean-
+        # exit stamp (no Aw-Snap restore), `open -n -g` on macOS (no focus
+        # steal, out of this job's pgroup), setsid exec fallback elsewhere.
+        # This backend previously used a bare exec and had NONE of those
+        # protections (2026-07-13 consolidation).
+        # shellcheck disable=SC1091
+        source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/browser-launch.sh"
+        launch_harness_chrome "$_chrome_bin" "$_prof_dir" \
             --remote-debugging-port=9557 \
             --user-data-dir="$HOME/.claude/browser-profiles/reddit-harness" \
             --no-first-run --no-default-browser-check \
             --disable-features=ChromeWhatsNewUI \
             "${_extra[@]}" \
-            about:blank >/dev/null 2>&1 &
-        disown
+            about:blank
         for _i in 1 2 3 4 5 6 7 8 9 10 11 12; do
             curl -sf --max-time 2 -o /dev/null http://127.0.0.1:9557/json/version 2>/dev/null && break
             sleep 1

package/skill/lib/twitter-backend.sh

@@ -334,64 +334,21 @@ ensure_twitter_browser_for_backend() {
             [ -n "$_stale_pids" ] && { kill -9 $_stale_pids 2>/dev/null || true; sleep 1; }
             rm -f "$_prof_dir/SingletonLock" "$_prof_dir/SingletonSocket" "$_prof_dir/SingletonCookie" 2>/dev/null || true
         fi
-        # Mark the profile's last exit as clean BEFORE launching. A SIGKILLed
-        # Chrome (wedge heal, stall abort) records exit_type=Crashed, and the
-        # next launch then session-restores the dead session's tab, which
-        # renders as a lingering "Aw, Snap" corpse the user keeps seeing
-        # (2026-07-13, twice). With the profile marked clean, Chrome opens
-        # ONLY our startup URL. Best-effort: a missing/corrupt Preferences
-        # file just skips.
-        "${S4L_PYTHON:-python3}" -c 'import json, os, sys
-p = os.path.join(sys.argv[1], "Default", "Preferences")
-try:
-    d = json.load(open(p))
-except Exception:
-    raise SystemExit(0)
-prof = d.setdefault("profile", {})
-prof["exit_type"] = "Normal"
-prof["exited_cleanly"] = True
-json.dump(d, open(p, "w"))' "$_prof_dir" 2>/dev/null || true
-        # Launch flags shared by both spawn paths below.
-        local _launch_args=(
-            --remote-debugging-port=9555
-            --user-data-dir="$HOME/.claude/browser-profiles/browser-harness"
-            --no-first-run --no-default-browser-check
-            --password-store=basic --use-mock-keychain
-            --disable-features=ChromeWhatsNewUI,CalculateNativeWinOcclusion
-            --disable-backgrounding-occluded-windows
-            "${_extra[@]}"
+        # Spawn via the SHARED launcher (skill/lib/browser-launch.sh): clean-
+        # exit stamp (no Aw-Snap restore), `open -n -g` on macOS (no focus
+        # steal, out of this job's pgroup), setsid exec fallback elsewhere.
+        # Do NOT hand-roll launch logic per backend.
+        # shellcheck disable=SC1091
+        source "$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/browser-launch.sh"
+        launch_harness_chrome "$_chrome_bin" "$_prof_dir" \
+            --remote-debugging-port=9555 \
+            --user-data-dir="$HOME/.claude/browser-profiles/browser-harness" \
+            --no-first-run --no-default-browser-check \
+            --password-store=basic --use-mock-keychain \
+            --disable-features=ChromeWhatsNewUI,CalculateNativeWinOcclusion \
+            --disable-backgrounding-occluded-windows \
+            "${_extra[@]}" \
             "${BH_LAUNCH_URL:-https://x.com}"
-        )
-        # macOS + .app-bundled Chrome: launch via `open -n -g` so the window
-        # NEVER steals the user's focus. A directly-exec'd Chrome always
-        # activates itself on launch — every legitimate relaunch (wedge heal,
-        # user quit, crash) popped a window over the user's work (the
-        # foreground-telemetry `cause:launched` events, 2026-07-13). -n forces
-        # a NEW instance (the user's personal Chrome may already be running;
-        # without -n LaunchServices would just poke it and drop our --args),
-        # -g launches WITHOUT activation. LaunchServices also parents the
-        # process outside this launchd job's process group, which independently
-        # covers the 2026-07-12 pgroup-reaping bug the setsid fallback fixes.
-        local _app_bundle=""
-        case "$_chrome_bin" in
-            *.app/Contents/MacOS/*) _app_bundle="${_chrome_bin%%/Contents/MacOS/*}" ;;
-        esac
-        if [ "$(uname -s)" = "Darwin" ] && [ -n "$_app_bundle" ] && [ -d "$_app_bundle" ]; then
-            open -n -g -a "$_app_bundle" --args "${_launch_args[@]}" >/dev/null 2>&1 || true
-        else
-            # Fallback (Linux, bare chromium binaries): direct exec in a NEW
-            # SESSION. os.setsid: Chrome must escape THIS job's process group —
-            # launchd SIGKILLs a transient job's whole process group the moment
-            # the shell exits (no AbandonProcessGroup), and `disown` does not
-            # change the pgid, so a plainly-backgrounded Chrome died on every
-            # cycle completion and the NEXT cycle's relaunch stole the user's
-            # focus (2026-07-12 root cause).
-            "${S4L_PYTHON:-python3}" -c 'import os,sys
-os.setsid()
-os.execv(sys.argv[1], sys.argv[1:])' \
-                "$_chrome_bin" "${_launch_args[@]}" >/dev/null 2>&1 &
-            disown
-        fi
         for _i in 1 2 3 4 5 6 7 8 9 10 11 12; do
             curl -sf --max-time 2 -o /dev/null http://127.0.0.1:9555/json/version 2>/dev/null && break
             sleep 1