social-autoposter 1.6.92 → 1.6.93

package/mcp/dist/index.js

@@ -235,11 +235,20 @@ const TOOL_ACTIVITY = {
     post_drafts: "posting",
     get_stats: "loading stats",
 };
+function toolActivityLabel(name, args) {
+    const fallback = TOOL_ACTIVITY[name];
+    if (!fallback)
+        return null;
+    const override = typeof args?.__saps_activity_label === "string"
+        ? args.__saps_activity_label.replace(/\s+/g, " ").trim().slice(0, 80)
+        : "";
+    return override || fallback;
+}
 function withActivity(name, cb) {
-    const label = TOOL_ACTIVITY[name];
-    if (!label)
+    if (!TOOL_ACTIVITY[name])
         return cb;
     return async (args, extra) => {
+        const label = toolActivityLabel(name, args) || TOOL_ACTIVITY[name];
         writeActivity("working", label);
         try {
             return await cb(args, extra);
@@ -640,6 +649,12 @@ async function postApproved(batchId, plan) {
                 "or set accounts.twitter.handle in config.json.",
         };
     }
+    // Mark posting active so scan_candidates DEFERS launching any scan for the
+    // duration of this batch (+ grace). This is the source-level mutual exclusion
+    // that actually fixes the hijack: the autopilot never launches a scan to race
+    // the post for the browser. Reset is guaranteed by scheduleShellLockRelease()
+    // in the finally below, so an early/failed post can't wedge scanning.
+    postingActive = true;
     // Posting is a priority over scanning: abort any in-flight plugin scan so the
     // approved post takes the browser immediately instead of waiting on the lock.
     // Plugin pipeline only — never affects the plist autopilot.
@@ -692,13 +707,12 @@ async function postApproved(batchId, plan) {
             });
         }
         finally {
-            // Don't free the lock immediately — hold it through a grace window so the
-            // NEXT approved card (a separate post_drafts call) reuses the same continuous
-            // hold, and a parked scan can't slip into the gap between cards. The timer
-            // releases it once posting truly stops (mirrors the plist holding the lock
-            // through the whole posting phase, then releasing at the end).
-            if (heldShellLock)
-                scheduleShellLockRelease();
+            // Always schedule the grace release (even if the lock acquire failed): the
+            // timer both frees the lock AND clears postingActive, so scanning resumes
+            // SHELL_LOCK_GRACE_MS after the last card. Holding through the grace lets the
+            // NEXT approved card reuse one continuous hold (mirrors the plist holding the
+            // lock through the whole posting phase, then releasing at the end).
+            scheduleShellLockRelease();
         }
     })();
     // Persist the poster's own stdout/stderr to a dated log. Without this the post
@@ -2293,6 +2307,15 @@ function sigkillAllScans() {
 // hold EXPANDS as more cards get approved and there is never a gap between cards.
 const SHELL_LOCK_GRACE_MS = Number(process.env.SAPS_POST_LOCK_GRACE_MS) || 60_000;
 let shellLockReleaseTimer = null;
+// True from the start of a post batch until SHELL_LOCK_GRACE_MS after the last
+// card. scan_candidates checks this and DEFERS launching a scan while it's set —
+// the real fix: posting and scanning are mutually exclusive at the SOURCE (both
+// are children of THIS one MCP), so we never even launch a scan that would race
+// the post for the browser lock. Having the post fight scans for the lock (the
+// prior approach) lost the race because the autopilot relaunches scans faster
+// than the post can hold the dir. Reset is guaranteed by the grace timer below,
+// so it can never wedge scanning permanently.
+let postingActive = false;
 function cancelScheduledShellLockRelease() {
     if (shellLockReleaseTimer) {
         clearTimeout(shellLockReleaseTimer);
@@ -2303,6 +2326,7 @@ function scheduleShellLockRelease() {
     cancelScheduledShellLockRelease();
     shellLockReleaseTimer = setTimeout(() => {
         shellLockReleaseTimer = null;
+        postingActive = false; // posting drained -> the autopilot may scan again
         releaseShellBrowserLock();
     }, SHELL_LOCK_GRACE_MS);
 }
@@ -2419,6 +2443,14 @@ function scanBusy() {
         "twitter-cycle slot). This is CONTENTION, not an empty result. Call scan_candidates again in " +
         "~20s to retry — do NOT conclude there are no candidates, and do NOT sleep; just re-call.");
 }
+// A post batch is in progress: scanning is deferred so posting has exclusive use
+// of the one shared browser (mutual exclusion at the source). Not an error.
+function scanDeferredForPost() {
+    return textContent("A post is in progress on this machine, so scanning is deferred — only one task drives X at a " +
+        "time and posting has priority. This is EXPECTED, not an error or an empty result. Call " +
+        "scan_candidates again shortly; it runs as soon as the current post batch finishes. Do NOT " +
+        "sleep or conclude there are no candidates; just re-call.");
+}
 // Resolve to {done:true,value} the moment `p` settles, or {done:false} after
 // `ms` — whichever is first. The job promise keeps running either way, so a
 // later poll re-attaches to it.
@@ -2535,6 +2567,14 @@ tool("scan_candidates", {
         "re-calling until it returns candidates. Never sleep or use a background wait to bridge the gap.",
     inputSchema: { project: z.string().optional() },
 }, async (args) => {
+    // MUTUAL EXCLUSION (the real hijack fix): while a post batch is in progress
+    // (or its grace-hold is active), DEFER scanning entirely rather than launching
+    // a scan that races the post for the one shared browser. Both the scan and the
+    // post are children of THIS MCP, so this in-process gate is exact — the
+    // autopilot never even starts a scan to interrupt a post. Posting always wins;
+    // the autopilot just re-calls and runs once the batch drains.
+    if (postingActive)
+        return scanDeferredForPost();
     // Long-poll the single in-flight scan job (see the ScanJob registry above).
     // A finished-but-unconsumed job: hand back its result and clear the slot so a
     // later call starts a fresh scan.
@@ -2641,7 +2681,7 @@ tool("submit_drafts", {
     // drafts are appended; a thread already in the queue (by URL) is skipped (one
     // draft per thread). Posted entries are KEPT in place so the 1-based card
     // numbering stays stable across runs — the menu bar, the chat table, and
-    // post_drafts all index the full array and filter on the `posted` flag.
+    // post_drafts all index the full array and filter finished rows.
     const queue = [
         ...(readPlan(REVIEW_QUEUE_ID)?.candidates ?? []),
     ];
@@ -2656,7 +2696,7 @@ tool("submit_drafts", {
         added++;
     }
     writePlan(REVIEW_QUEUE_ID, { candidates: queue });
-    const pending = queue.filter((c) => c.posted !== true);
+    const pending = queue.filter((c) => c.posted !== true && c.terminal !== true);
     // Drafts queued = the pipeline verified end-to-end without posting. This is the
     // onboarding "draft_verified" terminal goal (formerly completed by draft_cycle).
     if (added > 0)

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.92",
-  "installedAt": "2026-06-23T20:21:02.288Z"
+  "version": "1.6.93",
+  "installedAt": "2026-06-23T20:32:39.303Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.92",
+  "version": "1.6.93",
   "description": "Draft, review, approve, and autopilot X/Twitter posts. Thin desktop client over the S4L pipeline.",
   "long_description": "A guided assistant that drafts, reviews, and autopilots X/Twitter posts.\nTo get started:\n1. Click **Configure** and set every tool permission to **Always Allow**.\n2. Copy this prompt: **Set me up on S4L end to end**.\n3. Quit fully with CMD+Q, restart Claude, and paste the prompt into a new chat.",
   "author": {

package/mcp/menubar/s4l_menubar.py

@@ -164,6 +164,8 @@ class S4LMenuBar(rumps.App):
         self._review_lock = threading.Lock()
         self._panel_open = False
         self._posts_outstanding = 0
+        self._posting_batch_total = 0
+        self._posting_batch_done = 0
         self._spin_i = 0
         self._spinner = None  # fast rumps.Timer animating the title while busy
         # Reliable self-check of our own Accessibility (TCC) grant — this is the
@@ -465,6 +467,32 @@ class S4LMenuBar(rumps.App):
             self._maybe_start_review()
 
     # ---- draft review pop-ups ---------------------------------------------
+    def _posting_activity_label_locked(self):
+        """Progress for the current menu-bar approval burst.
+
+        The server receives one post_drafts call per approved card, so its native
+        view is always 1/1. The menu bar owns the burst queue and can show the
+        useful progress: current approved post / total approved so far.
+        """
+        if self._posts_outstanding <= 0:
+            return None
+        total = max(
+            self._posting_batch_total,
+            self._posting_batch_done + self._posts_outstanding,
+        )
+        current = min(total, self._posting_batch_done + 1)
+        return f"posting {current}/{total}"
+
+    def _write_posting_activity_locked(self):
+        label = self._posting_activity_label_locked()
+        if label:
+            st.write_activity("posting", label)
+        return label
+
+    def _reset_posting_progress_locked(self):
+        self._posting_batch_total = 0
+        self._posting_batch_done = 0
+
     def _maybe_start_review(self):
         if self._review_active:
             return
@@ -491,8 +519,10 @@ class S4LMenuBar(rumps.App):
         sig = tuple((d.get("n"), d.get("reply_text") or "") for d in drafts)
         if sig == self._last_review_sig:
             return
-        self._review_active = True
-        self._panel_open = True
+        with self._review_lock:
+            self._reset_posting_progress_locked()
+            self._review_active = True
+            self._panel_open = True
         try:
             import s4l_card
 
@@ -521,7 +551,9 @@ class S4LMenuBar(rumps.App):
             return
         with self._review_lock:
             self._posts_outstanding += 1
+            self._posting_batch_total += 1
             self._review_active = True
+            self._write_posting_activity_locked()
         self._post_q.put((batch, decision))
         self._ensure_post_worker()
 
@@ -534,6 +566,7 @@ class S4LMenuBar(rumps.App):
             self._panel_open = False
             if self._posts_outstanding <= 0:
                 self._review_active = False
+                self._reset_posting_progress_locked()
         st.clear_review_request()
         if not any(d.get("approved") for d in decisions):
             self._notify("S4L", "No drafts approved — nothing posted.")
@@ -548,19 +581,24 @@ class S4LMenuBar(rumps.App):
 
     def _post_worker_loop(self):
         # Serialized poster: one approved card at a time so two posts never drive
-        # the shared harness Chrome simultaneously. The server's post_drafts writes
-        # "posting" activity, so the menu-bar spinner shows automatically.
+        # the shared harness Chrome simultaneously. The menu bar passes a burst
+        # progress label into post_drafts, so the spinner shows e.g. "posting 17/95"
+        # even though each server call is still one approved draft.
         while True:
             batch, decision = self._post_q.get()  # blocks until a card is approved
             n = decision.get("n")
             try:
                 self._notify("S4L", f"Posting draft {n}…")
+                with self._review_lock:
+                    activity_label = self._posting_activity_label_locked()
                 if decision.get("edited"):
                     res = st.post_drafts(
-                        batch, edits=[{"n": n, "text": decision.get("text") or ""}]
+                        batch,
+                        edits=[{"n": n, "text": decision.get("text") or ""}],
+                        activity_label=activity_label,
                     )
                 else:
-                    res = st.post_drafts(batch, post=[n])
+                    res = st.post_drafts(batch, post=[n], activity_label=activity_label)
                 if res is None:
                     self._notify(
                         "S4L", "Couldn't post — open Claude Desktop and try the draft again."
@@ -577,9 +615,13 @@ class S4LMenuBar(rumps.App):
                 _capture(e, phase="post_card")
             finally:
                 with self._review_lock:
+                    self._posting_batch_done += 1
                     self._posts_outstanding -= 1
-                    if self._posts_outstanding <= 0 and not self._panel_open:
+                    if self._posts_outstanding > 0:
+                        self._write_posting_activity_locked()
+                    elif not self._panel_open:
                         self._review_active = False
+                        self._reset_posting_progress_locked()
                 self._post_q.task_done()
 
     def _render_title(self, setup_complete, ob, blocker):

package/mcp/menubar/s4l_state.py

@@ -299,6 +299,36 @@ def read_activity():
     return read_json("activity.json")
 
 
+def write_activity(state: str, label: str):
+    """Best-effort local activity update. The MCP server normally owns this file,
+    but the menu-bar posting queue knows the whole approved-card burst while the
+    server only sees one post_drafts call at a time."""
+    try:
+        p = Path(state_dir()) / "activity.json"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(
+            json.dumps(
+                {
+                    "state": state,
+                    "label": label,
+                    "since": time_iso(),
+                }
+            )
+            + "\n"
+        )
+    except Exception:
+        pass
+
+
+def time_iso():
+    try:
+        import datetime
+
+        return datetime.datetime.now(datetime.timezone.utc).isoformat()
+    except Exception:
+        return ""
+
+
 def read_review_request():
     return read_json("review-request.json")
 
@@ -340,12 +370,11 @@ def review_drafts(plan):
     return out
 
 
-def post_drafts(batch_id, post=None, edits=None, timeout=900):
+def post_drafts(batch_id, post=None, edits=None, timeout=900, activity_label=None):
     """Post approved drafts via the loopback tool. `post` = 1-based numbers to
     post as-is; `edits` = [{n, text}] to rewrite then post. Returns the parsed
     result, or None if the loopback is unreachable (Claude Desktop closed)."""
-    return loopback_tool(
-        "post_drafts",
-        {"batch_id": batch_id, "post": post or [], "edits": edits or []},
-        timeout=timeout,
-    )
+    args = {"batch_id": batch_id, "post": post or [], "edits": edits or []}
+    if activity_label:
+        args["__saps_activity_label"] = activity_label
+    return loopback_tool("post_drafts", args, timeout=timeout)

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.92",
+  "version": "1.6.93",
   "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.92",
+  "version": "1.6.93",
   "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/test_percard_posting.py

@@ -8,6 +8,7 @@ instance built via object.__new__ (bypassing rumps.App.__init__). Verifies:
   3. plain approvals -> post=[n]; edited approvals -> edits=[{n,text}]
   4. rejected cards never post
   5. _posts_outstanding / _review_active settle to idle once drained
+  6. activity progress reflects the approved burst total, not each 1-item call
 """
 import os
 import queue
@@ -41,13 +42,21 @@ overlap_detected = []
 inflight = {"n": 0}
 inflight_lock = threading.Lock()
 calls = []
+activity_events = []
 
-def fake_post_drafts(batch_id, post=None, edits=None, timeout=900):
+def fake_post_drafts(batch_id, post=None, edits=None, timeout=900, activity_label=None):
     with inflight_lock:
         inflight["n"] += 1
         if inflight["n"] > 1:
             overlap_detected.append(True)
-    calls.append({"batch": batch_id, "post": post or [], "edits": edits or []})
+    calls.append(
+        {
+            "batch": batch_id,
+            "post": post or [],
+            "edits": edits or [],
+            "activity_label": activity_label,
+        }
+    )
     time.sleep(0.15)  # simulate a slow post so overlaps would be caught
     with inflight_lock:
         inflight["n"] -= 1
@@ -57,6 +66,7 @@ def fake_post_drafts(batch_id, post=None, edits=None, timeout=900):
 
 st = types.ModuleType("s4l_state")
 st.post_drafts = fake_post_drafts
+st.write_activity = lambda state, label: activity_events.append((state, label))
 st.accessibility_trusted = lambda: True
 st.clear_review_request = lambda: None
 sys.modules["s4l_state"] = st
@@ -70,6 +80,8 @@ app._post_worker = None
 app._review_lock = threading.Lock()
 app._panel_open = True
 app._posts_outstanding = 0
+app._posting_batch_total = 0
+app._posting_batch_done = 0
 app._review_active = False
 app._notify = lambda title, msg: None  # silence Notification Center
 
@@ -106,6 +118,13 @@ posted_ns = [(c["post"], c["edits"]) for c in calls]
 expected = [([1], []), ([], [{"n": 2, "text": "edited two"}]), ([4], [])]
 if posted_ns != expected:
     fail.append(f"wrong calls/order: got {posted_ns}\n  expected {expected}")
+labels = [c["activity_label"] for c in calls if c.get("activity_label")]
+if not any(label == "posting 2/3" for label in labels):
+    fail.append(f"second post did not carry burst progress 2/3: labels={labels}")
+if not any(label == "posting 3/3" for label in labels):
+    fail.append(f"third post did not carry burst progress 3/3: labels={labels}")
+if not any(event == ("posting", "posting 1/3") for event in activity_events):
+    fail.append(f"activity never expanded first post to 1/3: events={activity_events}")
 if any(c["post"] == [3] or any(e.get("n") == 3 for e in c["edits"]) for c in calls):
     fail.append("rejected card #3 was posted")
 with app._review_lock: