@m13v/s4l 1.7.6-rc.7 → 1.7.6-rc.9

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.6-rc.7",
-  "installedAt": "2026-07-17T17:41:44.516Z"
+  "version": "1.7.6-rc.9",
+  "installedAt": "2026-07-17T17:54:17.719Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.6-rc.7",
+  "version": "1.7.6-rc.9",
   "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/menubar/s4l_menubar.py

@@ -2938,11 +2938,14 @@ class S4LMenuBar(rumps.App):
         flight, and not snoozed (the snooze label and gate take precedence)."""
         if pending_count <= 0 or self._review_active:
             return 0.0
-        # The reveal cadence is a cards-mode concept (its menu control is
-        # hidden in canvas mode, 2026-07-16); never hold canvas presentations
-        # on a stale cadence value the user can no longer see or change.
+        # Canvas never auto-pops (2026-07-17, user direction): the explicit
+        # "Review N pending drafts" click is the ONLY way to open it. Report
+        # the same indefinite hold as the cards-mode "Never" preset so the
+        # menu shows the courtesy line. The reveal cadence itself remains a
+        # cards-mode concept (its menu control is hidden in canvas mode,
+        # 2026-07-16), so a stale cadence value is never consulted here.
         if st.read_review_layout() != "cards":
-            return 0.0
+            return -1.0
         now = time.time()
         if now < self._review_snooze_until:
             return 0.0
@@ -3063,12 +3066,20 @@ class S4LMenuBar(rumps.App):
         # card keeps growing live) and skipped for focus=True (the menu's
         # "Review N pending drafts" is an explicit ask). _last_review_sig is NOT
         # stamped on a hold, so the same set still presents fresh when due.
-        # Cards mode only (2026-07-16): the cadence control is hidden while
-        # View Mode is Canvas, so a stale value must not silently pace or
-        # suppress canvas presentations. No panel is open past the
-        # _review_active branch above, so the preference IS the layout that
-        # is about to present.
-        if not focus and st.read_review_layout() == "cards":
+        # No panel is open past the _review_active branch above, so the
+        # preference IS the layout that is about to present.
+        if not focus:
+            if st.read_review_layout() != "cards":
+                # Canvas never auto-pops (2026-07-17, user direction): the
+                # explicit "Review N pending drafts" click (focus=True) is the
+                # ONLY way to open the canvas. The extend-open branch above
+                # still grows an already-open canvas live; _last_review_sig is
+                # NOT stamped here, so the whole backlog presents fresh on the
+                # click.
+                return
+            # Cards mode: pace fresh pop-ups by the reveal cadence. The
+            # cadence control is a cards-only concept (hidden while View Mode
+            # is Canvas, 2026-07-16), so it is never consulted for canvas.
             cadence = st.read_reveal_cadence()
             if cadence < 0:
                 # "Never" preset: cards never auto-pop, only an explicit
@@ -4069,7 +4080,12 @@ class S4LMenuBar(rumps.App):
             # now regardless.
             hold_until = self._reveal_hold_until(pending_count)
             if hold_until < 0:
-                items.append(self._label("Cards hidden — see count in the menu bar"))
+                if st.read_review_layout() == "cards":
+                    items.append(self._label("Cards hidden — see count in the menu bar"))
+                else:
+                    # Canvas mode: it never auto-opens; the review item above
+                    # is the one way in.
+                    items.append(self._label("Canvas opens from the review item above"))
             elif hold_until:
                 items.append(
                     self._label(

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.6-rc.7",
+  "version": "1.7.6-rc.9",
   "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.6-rc.7",
+  "version": "1.7.6-rc.9",
   "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/cdp_ready_check.py

@@ -1,44 +1,61 @@
 #!/usr/bin/env python3
-"""Real CDP readiness probe for the harness Chrome.
+"""Raw-websocket CDP readiness probe for the harness Chrome.
 
-Exit 0 when a full Playwright connect_over_cdp handshake completes against the
-given CDP URL, 1 when it does not. /json/version alone is a LIVENESS check: a
-wedged Chrome (process alive, HTTP answering, websocket upgrade completing,
-but the browser loop never servicing the CDP session) passes it, and every
-downstream attach then eats Playwright's 180s default timeout while holding
-the browser lock (S4L-4H, Karol 2026-07-11; identical wedge locally 2026-07-09,
-twice, same Chrome instance both times).
+Exit 0 when a real DevTools websocket handshake completes against the given
+CDP URL (browser-level connect + Browser.getVersion round-trip), 1 when it
+does not. /json/version alone is a LIVENESS check: a Chrome whose ws accept
+path died still passes it; this probe exercises the actual session dispatch.
 
-Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
+HISTORY — why raw websocket and NOT Playwright (2026-07-17): the original
+probe used sync_playwright().connect_over_cdp. Wedge-diag captures
+(skill/logs/wedge-diag/, v3 discriminator) proved that during every observed
+"wedge" the raw ws handshake completed in <5s while the Playwright connect
+timed out at 20s — with Chrome's DevToolsHandlerThread idle in kevent64 the
+whole time. The stall lives in Playwright's node driver under machine load,
+NOT in Chrome; the Playwright-based verdict was executing a healthy browser
+roughly hourly for days (every cdp_wedge relaunch 07-14..07-17). A probe must
+not depend on machinery heavier than the thing it probes. The S4L-4H /
+Karol-box incidents that motivated the deep probe are equally covered by the
+ws round-trip below (and in hindsight may have been this same client-side
+stall).
+
+Also preserves the renderer-liveness sweep (2026-07-14): a tab whose RENDERER
+crashed ("Aw, Snap") keeps its title/url in every listing while sitting dead;
+probe each page with a trivial Runtime.evaluate and reload it IN PLACE on
+failure — fresh renderer, no kill, no new window, no focus change.
 
-Prints a one-line JSON verdict to stdout so the caller can persist it
-(twitter-backend.sh writes it to skill/logs/cdp-health.json, which
-memory_snapshot.py carries onto the per-minute heartbeat sample).
+Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
 
-Falls back to an HTTP-only probe when playwright is not importable under the
-invoking interpreter, so a bare python3 caller degrades to the legacy
-liveness behavior instead of hard-failing.
+Prints a one-line JSON verdict to stdout (same shape/keys as before; mode is
+now "raw_ws"). Falls back to an HTTP-only probe when websocket-client is not
+importable, so a bare python3 caller degrades to liveness instead of failing.
 """
 import json
 import sys
 import time
+import urllib.request
+
+# ProxyHandler({}): loopback CDP must never route through a proxy. macOS
+# system proxy settings leak into urllib's default opener, and a box-wide
+# forwarder 403s 127.0.0.1 probes (2026-07-13 root cause of a "wedged
+# Chrome" misdiagnosis).
+_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+
+
+def _get_json(url: str, timeout: float):
+    with _OPENER.open(url, timeout=timeout) as r:
+        return json.loads(r.read())
 
 
 def main() -> int:
     url = (sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:9555").rstrip("/")
-    timeout_ms = int(sys.argv[2]) if len(sys.argv) > 2 else 8000
+    timeout_s = (int(sys.argv[2]) if len(sys.argv) > 2 else 20000) / 1000.0
     t0 = time.time()
     try:
-        from playwright.sync_api import sync_playwright
+        import websocket  # websocket-client, present in the owned runtime venv
     except Exception:
-        import urllib.request
         try:
-            # ProxyHandler({}): loopback CDP must never route through a proxy.
-            # macOS system proxy settings leak into urllib's default opener, and
-            # a box-wide forwarder 403s 127.0.0.1 probes (2026-07-13 root cause
-            # of the "wedged Chrome" misdiagnosis).
-            opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
-            opener.open(f"{url}/json/version", timeout=3)
+            _OPENER.open(f"{url}/json/version", timeout=3)
             print(json.dumps({"ready": True, "mode": "http-only"}))
             return 0
         except Exception as e:
@@ -46,35 +63,49 @@ def main() -> int:
                 "ready": False, "mode": "http-only", "error": str(e)[:120],
             }))
             return 1
+
+    def _ws_call(ws_url: str, method: str, timeout: float, **params):
+        # suppress_origin: Chrome 111+ rejects ws clients whose Origin header
+        # is not in --remote-allow-origins (same pattern as the tab parker).
+        ws = websocket.create_connection(ws_url, timeout=timeout, suppress_origin=True)
+        try:
+            ws.send(json.dumps({"id": 1, "method": method, "params": params}))
+            deadline = time.time() + timeout
+            while time.time() < deadline:
+                msg = json.loads(ws.recv())
+                if msg.get("id") == 1:
+                    return msg
+            raise TimeoutError(f"no reply to {method}")
+        finally:
+            ws.close()
+
     try:
-        with sync_playwright() as p:
-            browser = p.chromium.connect_over_cdp(url, timeout=timeout_ms)
-            n_contexts = len(browser.contexts)
-            # Renderer-liveness sweep (2026-07-14). A tab whose RENDERER
-            # crashed ("Aw, Snap", error code 5) keeps its normal title/url in
-            # every CDP listing and the browser-level handshake stays green,
-            # so it sat visibly dead for 20+ minutes with nothing entitled to
-            # touch it — below the wedge detector (browser-level) and the
-            # stall guard (scan-progress-level). Probe each page with a
-            # trivial evaluate; on failure reload the tab IN PLACE, which
-            # spawns a fresh renderer. No kill, no new window, no focus
-            # change. Best-effort: revival must never fail the readiness
-            # verdict the wedge gate depends on.
-            revived = 0
-            for ctx in browser.contexts:
-                for page in ctx.pages:
+        # Browser-level handshake: the readiness verdict.
+        info = _get_json(f"{url}/json/version", timeout=3)
+        _ws_call(info["webSocketDebuggerUrl"], "Browser.getVersion", timeout_s)
+
+        # Renderer-liveness sweep: revive crashed tabs in place, best-effort;
+        # revival must never fail the readiness verdict the wedge gate uses.
+        revived = 0
+        pages = []
+        try:
+            pages = [t for t in _get_json(f"{url}/json/list", timeout=3)
+                     if t.get("type") == "page" and t.get("webSocketDebuggerUrl")]
+            for t in pages:
+                try:
+                    _ws_call(t["webSocketDebuggerUrl"], "Runtime.evaluate",
+                             4.0, expression="1")
+                except Exception:
                     try:
-                        page.set_default_timeout(4000)
-                        page.evaluate("1")
+                        _ws_call(t["webSocketDebuggerUrl"], "Page.reload", 8.0)
+                        revived += 1
                     except Exception:
-                        try:
-                            page.reload(timeout=15000, wait_until="commit")
-                            revived += 1
-                        except Exception:
-                            pass
-            browser.close()
+                        pass
+        except Exception:
+            pass
+
         out = {
-            "ready": True, "mode": "cdp", "contexts": n_contexts,
+            "ready": True, "mode": "raw_ws", "contexts": len(pages),
             "elapsed_s": round(time.time() - t0, 2),
         }
         if revived:
@@ -83,7 +114,7 @@ def main() -> int:
         return 0
     except Exception as e:
         print(json.dumps({
-            "ready": False, "mode": "cdp",
+            "ready": False, "mode": "raw_ws",
             "elapsed_s": round(time.time() - t0, 2),
             "error": str(e)[:200].replace("\n", " "),
         }))