social-autoposter 1.6.165 → 1.6.166

package/mcp/dist/index.js

@@ -82,17 +82,21 @@ const MEMORY_SNAPSHOT_INTERVAL_SECS = 60;
 const STALL_WATCH_LABEL = "com.m13v.social-autopilot-stall-watch";
 const STALL_WATCH_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", `${STALL_WATCH_LABEL}.plist`);
 const STALL_WATCH_INTERVAL_SECS = 120;
-// On-screen overlay watcher supervisor. The harness status overlay ("S4L
-// running" / idle banner) only renders WHILE `harness_overlay.py watch` is
-// alive. That watcher is fire-and-forget with no supervisor of its own, so when
-// it dies (or the harness Chrome restarts) nothing brings it back and the
-// overlay silently disappears. Promote it to a first-class launchd job like its
-// siblings: RunAtLoad starts it at boot, the 60s StartInterval re-invokes the
-// idempotent supervisor script (pgrep guard => no-op while up) so a dead watcher
-// is respawned within a minute. Disable with SAPS_OVERLAY_WATCH=0.
+// On-screen overlay watcher. The harness status overlay ("S4L running" / idle
+// banner) only renders WHILE `harness_overlay.py watch` is alive. That watcher
+// is fire-and-forget with no supervisor of its own, so when it dies (or the
+// harness Chrome restarts) nothing brings it back and the overlay silently
+// disappears. Promote it to a first-class launchd job, but run the long-lived
+// watcher in the FOREGROUND under KeepAlive (NOT a StartInterval that re-invokes
+// a spawn-and-exit supervisor). The supervisor pattern races launchd on macOS:
+// the instant the kicker shell exits, launchd SIGKILLs the whole job process
+// group and reaps the just-spawned watcher before it can detach. Running the
+// watcher AS the job's main process makes launchd supervise it directly:
+// RunAtLoad starts it at boot, KeepAlive restarts it if it ever exits, and on
+// unload its SIGTERM handler clears the overlay cleanly. Disable with
+// SAPS_OVERLAY_WATCH=0.
 const OVERLAY_WATCH_LABEL = "com.m13v.social-overlay-watch";
 const OVERLAY_WATCH_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", `${OVERLAY_WATCH_LABEL}.plist`);
-const OVERLAY_WATCH_INTERVAL_SECS = 60;
 // Daily self-updater. Enabled alongside autopilot so a hands-free (headless)
 // install keeps itself current — the interactive `runtime` tool (action:'update')
 // only helps when
@@ -134,6 +138,9 @@ function launchdPath() {
 }
 function plistXml(opts) {
     const args = opts.programArgs.map((a) => `\t\t<string>${a}</string>`).join("\n");
+    const schedule = opts.keepAlive
+        ? `\t<key>KeepAlive</key>\n\t<true/>`
+        : `\t<key>StartInterval</key>\n\t<integer>${opts.intervalSecs}</integer>`;
     // Background (cron/autopilot) runs get the same Chrome the interactive cycle
     // uses, so a no-sudo ~/Applications install (which the shell's own resolver
     // doesn't scan) is still found off-screen. Omitted when Chrome resolves via
@@ -159,8 +166,7 @@ function plistXml(opts) {
 \t<array>
 ${args}
 \t</array>
-\t<key>StartInterval</key>
-\t<integer>${opts.intervalSecs}</integer>
+${schedule}
 \t<key>StandardOutPath</key>
 \t<string>${opts.stdoutLog}</string>
 \t<key>StandardErrorPath</key>
@@ -2695,15 +2701,19 @@ async function ensureMemorySnapshotInstalled() {
         return { ok: false, detail: e?.message || String(e) };
     }
 }
-// Install/refresh the on-screen overlay watcher launchd supervisor. Promotes the
+// Install/refresh the on-screen overlay watcher launchd job. Promotes the
 // harness status overlay from a best-effort, fired-from-other-tools nicety to a
-// first-class self-healing job (RunAtLoad + 60s StartInterval). The script it
-// drives (skill/run-overlay-watch.sh) is idempotent via a pgrep guard, so the
-// 60s re-invocation is a fast no-op while the watcher is up and respawns it
-// within a minute if it ever dies or the harness Chrome restarts. SAPS_PYTHON is
-// baked by plistXml; we add SAPS_LOG_DIR (so the watcher reads the same cycle
-// logs to decide busy/idle) and the harness CDP URL. Disable with
-// SAPS_OVERLAY_WATCH=0.
+// first-class self-healing job. We run `harness_overlay.py watch` directly in
+// the FOREGROUND under KeepAlive (RunAtLoad starts it at boot; launchd restarts
+// it if it ever exits) rather than a StartInterval that re-fires a spawn-and-exit
+// supervisor: on macOS that supervisor races launchd, which SIGKILLs the job's
+// process group the instant the kicker shell exits and reaps the just-spawned
+// watcher before it can detach (verified on the box: the watcher caught the
+// group SIGTERM and cleared the overlay every cycle). harness_overlay.py holds a
+// singleton flock so the MCP's best-effort run-overlay-watch.sh lane can never
+// double-paint. SAPS_PYTHON is baked by plistXml; we add SAPS_LOG_DIR (so the
+// watcher reads the same cycle logs to decide busy/idle) and the harness CDP
+// URL. Disable with SAPS_OVERLAY_WATCH=0.
 async function ensureOverlayWatchInstalled() {
     try {
         if (process.platform !== "darwin")
@@ -2719,8 +2729,9 @@ async function ensureOverlayWatchInstalled() {
         }
         const xml = plistXml({
             label: OVERLAY_WATCH_LABEL,
-            programArgs: ["/bin/bash", path.join(repoDir(), "skill", "run-overlay-watch.sh")],
-            intervalSecs: OVERLAY_WATCH_INTERVAL_SECS,
+            programArgs: [resolvePython(), path.join(repoDir(), "scripts", "harness_overlay.py"), "watch"],
+            intervalSecs: 0,
+            keepAlive: true,
             runAtLoad: true,
             stdoutLog: path.join(logDir, "launchd-overlay-watch-stdout.log"),
             stderrLog: path.join(logDir, "launchd-overlay-watch-stderr.log"),

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.165",
-  "installedAt": "2026-06-30T02:01:48.183Z"
+  "version": "1.6.166",
+  "installedAt": "2026-06-30T02:20:22.438Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.165",
+  "version": "1.6.166",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "The disclaimer above is generic Claude boilerplate. S4L 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 fully with CMD+Q, restart Claude, and paste the prompt into a new chat.",
   "author": {

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.165",
+  "version": "1.6.166",
   "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": "social-autoposter",
-  "version": "1.6.165",
+  "version": "1.6.166",
   "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/harness_overlay.py

@@ -36,6 +36,7 @@ down it sleeps and retries; it never crashes the pipeline.
 
 from __future__ import annotations
 
+import fcntl
 import glob
 import json
 import os
@@ -454,6 +455,20 @@ def cmd_watch(interval: float = 2.0) -> int:
     holds ONE CDP connection open across ticks (light, and friendly to the
     poster's concurrent CDP session) and only reconnects when the harness Chrome
     comes/goes. Never raises into the pipeline."""
+    # Singleton guard: there must be exactly ONE watcher painting at a time, or
+    # two loops fight over the same overlay (double heartbeat, flicker). Two start
+    # lanes can race to spawn this: the MCP's foreground KeepAlive launchd job and
+    # the best-effort run-overlay-watch.sh supervisor. Hold an exclusive,
+    # non-blocking flock for the life of the process; if another watcher already
+    # holds it, exit 0 quietly and let that one own the overlay. The lock fd is
+    # intentionally leaked (kept open) until the process dies so the OS releases
+    # it automatically on exit/kill.
+    try:
+        _lock_fd = os.open("/tmp/saps_overlay_watch.lock", os.O_CREAT | os.O_RDWR, 0o644)
+        fcntl.flock(_lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError:
+        print("another overlay watcher already running; exiting", file=sys.stderr)
+        return 0
     print(f"watching {LOG_DIR}/twitter-cycle-*.log -> overlay on {CDP_URL} (Ctrl-C to stop)")
     # Treat SIGTERM (launchd unload, `kill`) like Ctrl-C so the overlay is
     # cleared on the way out instead of lingering until the next navigation.

package/skill/run-overlay-watch.sh

@@ -73,6 +73,20 @@ WATCH_LOG="${SAPS_LOG_DIR}/overlay-watch.log"
 # --- spawn detached ----------------------------------------------------------
 cd "${REPO_DIR}" || exit 0
 echo "[overlay-watch] $(date '+%Y-%m-%d %H:%M:%S') starting watcher py=${PYBIN} cdp=${TWITTER_CDP_URL} log=${SAPS_LOG_DIR}" >>"${WATCH_LOG}" 2>&1
-nohup "${PYBIN}" "${OVERLAY_PY}" watch >>"${WATCH_LOG}" 2>&1 &
+# Spawn the watcher in a NEW SESSION so it outlives this supervisor.
+# When launchd fires this script (StartInterval 60), the script is the job's
+# main process; the moment it exits, launchd reaps the WHOLE job process group.
+# `nohup` only blocks SIGHUP, not that group SIGKILL, so a plain `nohup ... &`
+# child dies the instant we `exit 0` (it survives only when this runs from an
+# interactive shell, which is NOT a launchd job). macOS ships no setsid(1), so
+# use the python we already resolved to os.setsid() off the launchd group, then
+# exec the real watcher. The watcher's own interpreter self-heal (os.execv)
+# keeps the new session.
+nohup "${PYBIN}" -c 'import os, sys
+try:
+    os.setsid()
+except OSError:
+    pass
+os.execv(sys.argv[1], sys.argv[1:])' "${PYBIN}" "${OVERLAY_PY}" watch >>"${WATCH_LOG}" 2>&1 &
 disown 2>/dev/null || true
 exit 0