social-autoposter 1.6.62 → 1.6.64

package/bin/cli.js

@@ -705,6 +705,22 @@ function generatePlists() {
       stdoutLog: `${DEST}/skill/logs/launchd-self-update-stdout.log`,
       stderrLog: `${DEST}/skill/logs/launchd-self-update-stderr.log`,
     },
+    {
+      // On-screen overlay watcher supervisor. The overlay (harness status banner
+      // + interactive draft sidebar) only renders WHILE harness_overlay.py watch
+      // runs. The supervisor is idempotent (pgrep guard), so a 60s StartInterval
+      // is a no-op while the watcher is up and re-spawns it within a minute if it
+      // ever dies. RunAtLoad starts it right after install. This is what makes the
+      // overlay appear on headless / remote installs (Lane A); the MCP covers the
+      // pure-.mcpb lane by calling the same script on draft_cycle / autopilot.
+      file: 'com.m13v.social-overlay-watch.plist',
+      label: 'com.m13v.social-overlay-watch',
+      script: `${DEST}/skill/run-overlay-watch.sh`,
+      interval: 60,
+      runAtLoad: true,
+      stdoutLog: `${DEST}/skill/logs/launchd-overlay-watch-stdout.log`,
+      stderrLog: `${DEST}/skill/logs/launchd-overlay-watch-stderr.log`,
+    },
   ];
 
   const driver = scheduler.driverFor();

package/mcp/dist/index.js

@@ -222,6 +222,32 @@ function cycleProgressMessage(line) {
         return `Cycle stopped (${m[1]}).`;
     return null;
 }
+// Start the twitter-harness on-screen overlay watcher if it isn't already up.
+// The overlay (status banner + interactive draft sidebar) only renders WHILE
+// `harness_overlay.py watch` runs. The supervisor script is idempotent (pgrep
+// guard), so calling this on every draft_cycle / autopilot-enable / show-browser
+// is safe: it spawns at most one detached watcher and is a fast no-op otherwise.
+//
+// We thread SAPS_PYTHON (the owned uv runtime, so the watcher resolves a
+// playwright-capable interpreter on Lane B / .mcpb installs that have no system
+// python) and SAPS_LOG_DIR (the materialized repo's skill/logs, so the watcher
+// reads the SAME cycle logs this run writes to decide busy/idle). Fire-and-forget:
+// a failure here must never break the cycle it's decorating.
+async function ensureOverlayWatch() {
+    try {
+        await run("bash", ["skill/run-overlay-watch.sh"], {
+            timeoutMs: 20_000,
+            env: {
+                SAPS_PYTHON: resolvePython(),
+                SAPS_LOG_DIR: path.join(repoDir(), "skill", "logs"),
+                TWITTER_CDP_URL: process.env.TWITTER_CDP_URL || "http://127.0.0.1:9555",
+            },
+        });
+    }
+    catch {
+        /* best-effort: the overlay is a nicety, never a blocker */
+    }
+}
 async function produceDrafts(project, onProgress) {
     // Run the real pipeline in DRAFT_ONLY mode: scan -> score -> draft -> link-gen,
     // then STOP before posting. The script prints `DRAFT_ONLY_PLAN=<path>` and
@@ -240,6 +266,9 @@ async function produceDrafts(project, onProgress) {
     };
     if (project)
         env.SAPS_FORCE_PROJECT = project;
+    // Bring the on-screen overlay up alongside the live harness window so the user
+    // watching the scan/scrape sees status + queued drafts. Idempotent + detached.
+    await ensureOverlayWatch();
     let step = 0;
     let lastMsg = "";
     // ONE predictable, host-independent place to watch a draft_cycle run, so any
@@ -971,6 +1000,9 @@ tool("autopilot", {
         });
     }
     if (action === "enable") {
+        // Bring up the on-screen overlay watcher so background autopilot cycles
+        // still paint the harness status/sidebar. Idempotent + detached.
+        await ensureOverlayWatch();
         // 1) Cycle plist. Write one pointing at the self-update guard ONLY if no
         //    plist exists yet; never overwrite a hand-tuned/dev plist.
         const createdCycle = ensurePlist(TWITTER_AUTOPILOT_PLIST, plistXml({
@@ -1480,6 +1512,10 @@ tool("show_browser_to_user", {
         }
         return jsonContent({ ok: true, brought_to_front: true, port: res.port });
     }
+    // If the user is about to watch the live browser, make sure the on-screen
+    // overlay watcher is up too so the harness window carries status + drafts.
+    if (action === "start")
+        await ensureOverlayWatch();
     const ensured = await screencast.ensure(typeof args?.port === "number" ? args.port : undefined);
     if (!ensured.ok) {
         const message = ensured.error === "no_browser"

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.60",
-  "installedAt": "2026-06-05T02:22:33.297Z"
+  "version": "1.6.64",
+  "installedAt": "2026-06-05T16:30:35.428Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-autoposter",
-  "version": "1.6.62",
+  "version": "1.6.64",
   "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

@@ -517,12 +517,29 @@ def _fetch_drafts(limit: int = 40) -> list:
 
 # --- cycle-log -> friendly status -------------------------------------------
 
+def _safe_mtime(p: str) -> float:
+    """getmtime that tolerates the file vanishing mid-scan (log rotation race).
+
+    The watch loop runs forever while cycles rotate/delete logs underneath it.
+    A bare os.path.getmtime on a path that disappeared between the glob and the
+    stat raises FileNotFoundError and (previously) killed the whole watcher,
+    dropping the overlay until something restarted it. Treat a gone file as
+    infinitely old so it just loses the max() race instead of crashing.
+    """
+    try:
+        return os.path.getmtime(p)
+    except OSError:
+        return 0.0
+
+
 def _latest_cycle_log() -> Path | None:
     files = glob.glob(str(LOG_DIR / "twitter-cycle-*.log"))
     if not files:
         return None
-    newest = max(files, key=lambda f: os.path.getmtime(f))
-    return Path(newest)
+    newest = max(files, key=_safe_mtime)
+    # The winner could STILL have been deleted between selection and use; the
+    # caller (_current_status) stats it again, so hand back None if it's gone.
+    return Path(newest) if os.path.exists(newest) else None
 
 
 _RE_SCAN = re.compile(r"project='([^']+)'\s+q=(['\"])(.*?)\2\s+kept=(\d+)")
@@ -575,7 +592,7 @@ def _current_status() -> str:
     log = _latest_cycle_log()
     if not log:
         return "Idle \u2014 waiting for the next cycle\u2026"
-    age = time.time() - os.path.getmtime(log)
+    age = time.time() - _safe_mtime(str(log))
     if age > IDLE_AFTER_SEC:
         return "Idle \u2014 waiting for the next cycle\u2026"
     return _tail_last_meaningful(log) or "Working\u2026"
@@ -638,7 +655,12 @@ def cmd_watch(interval: float = 2.0) -> int:
     last_sb_sig = None
     try:
         while True:
-            status = _current_status()
+            # Never let status computation (log globbing/stat, all racing against
+            # live log rotation) kill the watcher; fall back to a neutral status.
+            try:
+                status = _current_status()
+            except Exception:
+                status = "Working\u2026"
             try:
                 if h is None:
                     h = Harness().__enter__()

package/skill/lib/linkedin-backend.sh

@@ -192,24 +192,57 @@ _acquire_linkedin_pipeline_lock() {
         return 0
     fi
     local _who="${SAPS_PIPELINE_NAME:-$(basename "${0:-linkedin-pipeline}")}"
+    # WAIT, don't bail. Aligned 2026-06-04 with Twitter's skill/lock.sh::acquire_lock
+    # so an overlapping LinkedIn fire (e.g. stats-linkedin's :23 slot landing on
+    # top of run-linkedin's :14 post still finishing) queues for the 9556 Chrome
+    # instead of `exit 0`-skipping. Previously the live-holder branch bailed, which
+    # systematically starved stats-linkedin every time its slot collided with the
+    # ~9min post pipeline, so comment-stats never refreshed. Bounded by a timeout
+    # (default 1h) and a 3h lock-age safety net, matching lock.sh.
+    local _waited=0
+    local _timeout="${SAPS_LINKEDIN_PIPELINE_LOCK_TIMEOUT:-3600}"
+    local _logged_wait=false
     while : ; do
         if mkdir "$_LI_PIPELINE_LOCK_DIR" 2>/dev/null; then
             echo "$$" > "$_LI_PIPELINE_LOCK_DIR/pid"
             echo "$_who" > "$_LI_PIPELINE_LOCK_DIR/holder"
             export _LI_PIPELINE_LOCK_HELD=1
-            echo "[$(date +%H:%M:%S)] linkedin-pipeline lock ACQUIRED by $_who (pid $$)" >&2
+            echo "[$(date +%H:%M:%S)] linkedin-pipeline lock ACQUIRED by $_who (pid $$) waited=${_waited}s" >&2
             return 0
         fi
         local _h_pid _h_who
         _h_pid="$(cat "$_LI_PIPELINE_LOCK_DIR/pid" 2>/dev/null || echo "")"
         _h_who="$(cat "$_LI_PIPELINE_LOCK_DIR/holder" 2>/dev/null || echo "?")"
+        # Reclaim a stale lock left by a dead holder (no release trap by design).
         if [ -z "$_h_pid" ] || ! kill -0 "$_h_pid" 2>/dev/null; then
             echo "[$(date +%H:%M:%S)] linkedin-pipeline lock: reclaiming stale lock (dead holder ${_h_who} pid ${_h_pid:-unknown})" >&2
             rm -rf "$_LI_PIPELINE_LOCK_DIR"
             continue
         fi
-        echo "[$(date +%H:%M:%S)] linkedin-pipeline lock: held by ${_h_who} (pid ${_h_pid}); ${_who} exiting this fire to avoid two drivers on the 9556 Chrome" >&2
-        exit 0
+        # Safety net: reclaim any lock older than 3h regardless of holder liveness.
+        # watchdog_hung_runs.py SIGTERMs a hung holder long before this fires;
+        # mirrors the 10800s ceiling in lock.sh::acquire_lock.
+        if [ -d "$_LI_PIPELINE_LOCK_DIR" ]; then
+            local _lock_age
+            _lock_age=$(( $(date +%s) - $(stat -f %m "$_LI_PIPELINE_LOCK_DIR" 2>/dev/null || stat -c %Y "$_LI_PIPELINE_LOCK_DIR" 2>/dev/null || date +%s) ))
+            if [ "$_lock_age" -gt 10800 ]; then
+                echo "[$(date +%H:%M:%S)] linkedin-pipeline lock: removing lock older than 3h (age ${_lock_age}s, holder ${_h_who})" >&2
+                rm -rf "$_LI_PIPELINE_LOCK_DIR"
+                continue
+            fi
+        fi
+        # Timed out waiting -> skip this fire (launchd will re-fire next slot).
+        if [ "$_waited" -ge "$_timeout" ]; then
+            echo "[$(date +%H:%M:%S)] linkedin-pipeline lock: still held by ${_h_who} (pid ${_h_pid}) after $((_timeout/60))min; ${_who} skipping this fire" >&2
+            exit 0
+        fi
+        # Surface the holder once when we first start waiting.
+        if [ "$_logged_wait" = "false" ]; then
+            echo "[$(date +%H:%M:%S)] linkedin-pipeline lock: held by ${_h_who} (pid ${_h_pid}); ${_who} waiting (timeout $((_timeout/60))min)..." >&2
+            _logged_wait=true
+        fi
+        sleep 2
+        _waited=$((_waited + 2))
     done
 }
 

package/skill/run-overlay-watch.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Idempotent supervisor for the twitter-harness on-screen overlay watcher.
+#
+# WHAT: keeps exactly ONE `harness_overlay.py watch` process alive. That watcher
+# injects the status overlay + interactive draft sidebar into the twitter-harness
+# Chrome window so a human watching the harness sees what the pipeline is doing
+# and can preview queued drafts.
+#
+# WHY a supervisor: the overlay only renders WHILE the watch process runs. It was
+# previously a manual, local-only process, so it never appeared on headless /
+# remote installs. This script makes it self-starting from BOTH install lanes:
+#   - Lane A (npm/cli): launchd job `com.m13v.social-overlay-watch` (StartInterval
+#     60 + RunAtLoad) re-invokes this script every minute; the pgrep guard makes
+#     re-invocation a no-op while the watcher is already up.
+#   - Lane B (.mcpb / pure MCP): the MCP calls this script on draft_cycle /
+#     autopilot-enable / show_browser_to_user, threading SAPS_PYTHON + SAPS_LOG_DIR.
+#
+# IDEMPOTENT: safe to call on a 60s timer. If a watcher is already running it
+# exits 0 immediately. Otherwise it spawns one detached (nohup, own session) and
+# returns; the spawned watcher then runs until the machine/MCP tears it down.
+#
+# This script is intentionally NOT locked: the overlay UX is expected to evolve.
+
+set -u
+
+# --- resolve the repo this script lives in (works from launchd + MCP cwd) -----
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+OVERLAY_PY="${REPO_DIR}/scripts/harness_overlay.py"
+
+if [ ! -f "${OVERLAY_PY}" ]; then
+  echo "[overlay-watch] harness_overlay.py not found at ${OVERLAY_PY}; nothing to do" >&2
+  exit 0
+fi
+
+# --- idempotency guard: at most one watcher, ever ----------------------------
+# Match the full `harness_overlay.py watch` invocation (NOT a bare `grep -r`, so
+# this never trips the BSD-grep-on-FIFO hang noted in the repo CLAUDE.md).
+if pgrep -f "harness_overlay.py watch" >/dev/null 2>&1; then
+  exit 0
+fi
+
+# --- resolve a python interpreter --------------------------------------------
+# harness_overlay.py self-heals to a playwright-capable interpreter on its own
+# (see _ensure_playwright_interpreter), so any python3 that exists is fine to
+# launch with. Prefer the MCP-threaded SAPS_PYTHON (owned uv runtime), then the
+# usual suspects.
+PYBIN=""
+for _cand in \
+  "${SAPS_PYTHON:-}" \
+  "/opt/homebrew/bin/python3.11" \
+  "/usr/bin/python3" \
+  "/opt/homebrew/bin/python3"
+do
+  if [ -n "${_cand}" ] && [ -x "${_cand}" ]; then PYBIN="${_cand}"; break; fi
+done
+if [ -z "${PYBIN}" ]; then
+  PYBIN="$(command -v python3 2>/dev/null || true)"
+fi
+if [ -z "${PYBIN}" ]; then
+  echo "[overlay-watch] no python3 found; cannot start overlay watcher" >&2
+  exit 0
+fi
+
+# --- env the watcher needs ---------------------------------------------------
+# SAPS_LOG_DIR: where harness_overlay.py reads cycle logs to decide busy/idle.
+# Default to this repo's skill/logs (MCP overrides it to the materialized repo).
+export SAPS_LOG_DIR="${SAPS_LOG_DIR:-${REPO_DIR}/skill/logs}"
+# CDP target for the twitter harness Chrome (honor BYO-Chrome installs).
+export TWITTER_CDP_URL="${TWITTER_CDP_URL:-http://127.0.0.1:9555}"
+mkdir -p "${SAPS_LOG_DIR}" 2>/dev/null || true
+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 &
+disown 2>/dev/null || true
+exit 0