social-autoposter 1.6.112 → 1.6.113

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.112",
-  "installedAt": "2026-06-25T05:09:23.776Z"
+  "version": "1.6.113",
+  "installedAt": "2026-06-25T19:38:00.335Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.112",
+  "version": "1.6.113",
   "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 end to end**\n\n2\\. Quit fully with CMD+Q, restart Claude, and paste the prompt into a new chat.",
   "author": {

package/mcp/menubar/s4l_card.py

@@ -241,6 +241,30 @@ class _ReviewController(NSObject):
         else:
             self._render()
 
+    @objc.python_method
+    def extend_drafts(self, drafts):
+        """Append newly-queued drafts to an OPEN card. Without this, a card built
+        when N drafts were pending froze at "of N": every draft that arrived after
+        the card opened was stranded behind it (the menu bar bailed while a panel
+        was up). Dedups by plan index `n`, never disturbs the card on screen, and
+        refreshes the title-bar counter live so the backlog is honest."""
+        if self._panel is None:
+            return 0
+        have = {d.get("n") for d in self._drafts}
+        added = [d for d in drafts if d.get("n") not in have]
+        if not added:
+            return 0
+        self._drafts.extend(added)
+        # Update only the "X of N" counter; do NOT re-render the body (that would
+        # reset the caret / clobber an in-progress edit on the current card).
+        try:
+            self._panel.setTitle_(
+                f"Review draft {self._idx + 1} of {len(self._drafts)}"
+            )
+        except Exception:
+            pass
+        return len(added)
+
     @objc.python_method
     def _fire_decision(self):
         # Fire the per-card callback the instant a decision is made, so an
@@ -305,3 +329,15 @@ def present_review(drafts, on_decision=None, on_complete=None):
     _active = _ReviewController.alloc().initWithDrafts_onDecision_onComplete_(
         drafts, on_decision, on_complete
     )
+
+
+def extend_active(drafts):
+    """Push newly-queued drafts into the open review card, if one is up. Returns
+    the count actually added (0 if no card is open or nothing is new). Main thread
+    only (called from the menu bar's rumps timer)."""
+    if _active is None:
+        return 0
+    try:
+        return _active.extend_drafts(drafts)
+    except Exception:
+        return 0

package/mcp/menubar/s4l_menubar.py

@@ -521,8 +521,6 @@ class S4LMenuBar(rumps.App):
         self._posting_batch_done = 0
 
     def _maybe_start_review(self):
-        if self._review_active:
-            return
         req = st.read_review_request()
         if not req:
             return
@@ -546,6 +544,26 @@ 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
+        # A review is already in flight. Two cases:
+        #  - A card is ON SCREEN (_panel_open): push the newly-queued drafts into
+        #    the open card so the "X of N" counter and the reviewable stack grow
+        #    live. This is the fix for the "card froze at 1 of 4 while 137 piled
+        #    up" bug — drafts that arrived after the card opened used to be
+        #    stranded because this method returned early on _review_active.
+        #  - Posting is DRAINING with no panel up (_review_active but not
+        #    _panel_open): leave the signature untouched so the full pending set
+        #    is presented fresh once the drain completes (don't pop a card mid-post).
+        if self._review_active:
+            if self._panel_open:
+                try:
+                    import s4l_card
+
+                    s4l_card.extend_active(drafts)
+                except Exception as e:
+                    sys.stderr.write(f"[s4l-menubar] extend cards failed: {e}\n")
+                    sys.stderr.flush()
+                self._last_review_sig = sig
+            return
         with self._review_lock:
             self._reset_posting_progress_locked()
             self._review_active = True
@@ -604,7 +622,23 @@ class S4LMenuBar(rumps.App):
             if self._posts_outstanding <= 0:
                 self._review_active = False
                 self._reset_posting_progress_locked()
-        st.clear_review_request()
+        # Only clear the review marker when the queue is actually drained. The old
+        # code cleared it unconditionally, so if the user closed the card with
+        # drafts still undecided (or more had piled up than they reviewed), the
+        # backlog was stranded — presentation is gated on this marker. Keep it when
+        # anything remains so the leftover re-presents fresh on the next tick.
+        remaining = 0
+        try:
+            req = st.read_review_request()
+            if req:
+                remaining = len(st.review_drafts(st.read_plan(req.get("plan_path") or "")))
+        except Exception:
+            remaining = 0
+        if remaining <= 0:
+            st.clear_review_request()
+        # Drop the dedup signature so whatever is left is presented fresh (not
+        # suppressed as "already shown") once posting finishes draining.
+        self._last_review_sig = None
         if not any(d.get("approved") for d in decisions):
             self._notify("S4L", "No drafts approved — nothing posted.")
 

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.112",
+  "version": "1.6.113",
   "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.112",
+  "version": "1.6.113",
   "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/project_topics.py

@@ -2,8 +2,20 @@
 """Shared accessor for project_search_topics.
 
 Single chokepoint for every runtime consumer of the per-project topic list
-that used to live in config.json (projects[].search_topics[]). Reads from
-the DB only — config.json is seed-only via scripts/seed_search_topics.py.
+that used to live in config.json (projects[].search_topics[]). The DB
+(project_search_topics) is the living runtime universe (invent/decay/exclude
+operate on it); config.json's search_topics[] is the human-authored SEED.
+
+Self-healing seed-on-empty: if the DB has no active topics for a project that
+DOES carry a search_topics[] seed in config.json, this module mirrors that seed
+into the DB once (first-run bootstrap) and re-reads. That makes "add a project
+to config.json" sufficient to make it run, with no separate manual
+seed_search_topics.py step to forget. Before this, a fully-configured project
+(weight, enabled, topics) could silently never run because the manual seed was
+skipped (Capstacker 2026-06, Karol/pamba earlier). This is a SEED-ON-EMPTY, not
+a live config.json fallback: it fires only for a project the DB has never heard
+of, and once rows exist the living state owns the universe and it never runs
+again — so it does not resurrect decayed/excluded topics.
 
 Why this module exists: 10+ scripts (pick_project, score_twitter_candidates,
 scan_twitter_mentions_browser, scan_dm_candidates, post_reddit, post_github,
@@ -34,12 +46,15 @@ Public surface:
 """
 from __future__ import annotations
 
+import json
 import os
 import sys
-from typing import Dict, List
+from typing import Dict, List, Set
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
+CONFIG_PATH = os.path.expanduser("~/social-autoposter/config.json")
+
 
 class TopicsError(RuntimeError):
     """Raised when the topics API call itself fails (network, 5xx, auth).
@@ -50,15 +65,12 @@ class TopicsError(RuntimeError):
 
 
 _CACHE: Dict[str, List[str]] = {}
+_BOOTSTRAP_ATTEMPTED: Set[str] = set()
 
 
-def topics_for_project(name: str) -> List[str]:
-    """Active topics for one project (DB-only, process-cached)."""
-    if not name:
-        return []
-    key = name.strip()
-    if key in _CACHE:
-        return _CACHE[key]
+def _fetch_active_topics(key: str) -> List[str]:
+    """Read active topics for one project from the DB. Raises TopicsError on a
+    real API failure (network, 5xx, auth) so the cycle aborts loudly."""
     try:
         from http_api import api_get
         resp = api_get(
@@ -78,12 +90,96 @@ def topics_for_project(name: str) -> List[str]:
         if t and t not in seen:
             seen.add(t)
             topics.append(t)
+    return topics
+
+
+def _config_topics_for(name: str) -> List[str]:
+    """The seed search_topics[] for one project from config.json (de-duped).
+    Used only to bootstrap a project the DB has never seen — see
+    _bootstrap_from_config."""
+    try:
+        with open(CONFIG_PATH) as f:
+            cfg = json.load(f)
+    except Exception:
+        return []
+    key = name.strip().lower()
+    for p in cfg.get("projects", []):
+        if (p.get("name") or "").strip().lower() == key:
+            seen, out = set(), []
+            for t in (p.get("search_topics") or []):
+                t = (t or "").strip()
+                if t and t not in seen:
+                    seen.add(t)
+                    out.append(t)
+            return out
+    return []
+
+
+def _bootstrap_from_config(name: str) -> int:
+    """One-time self-heal: mirror a project's config.json search_topics into the
+    DB when it has zero active rows. Idempotent (the API upserts on
+    install_id+project+topic), so a duplicate/concurrent run is harmless. Never
+    raises: a seed failure is logged and treated as "no topics" so the read path
+    is never worse than before, just loud instead of silent. Returns the number
+    of topics POSTed. Honors SAPS_NO_TOPIC_AUTOSEED=1 for read-only contexts."""
+    if os.environ.get("SAPS_NO_TOPIC_AUTOSEED") == "1":
+        return 0
+    topics = _config_topics_for(name)
+    if not topics:
+        return 0
+    try:
+        from http_api import api_post
+    except Exception as e:
+        sys.stderr.write(
+            f"[project_topics] auto-seed unavailable project={name!r}: {e}\n"
+        )
+        return 0
+    seeded = 0
+    for topic in topics:
+        try:
+            api_post(
+                "/api/v1/project-search-topics",
+                body={"project": name, "topic": topic,
+                      "source": "seed", "status": "active"},
+            )
+            seeded += 1
+        except Exception as e:
+            sys.stderr.write(
+                f"[project_topics] auto-seed FAILED project={name!r} "
+                f"topic={topic!r}: {e}\n"
+            )
+    if seeded:
+        sys.stderr.write(
+            f"[project_topics] auto-seeded {seeded}/{len(topics)} topic(s) for "
+            f"project={name!r} from config.json (first-run bootstrap)\n"
+        )
+    return seeded
+
+
+def topics_for_project(name: str) -> List[str]:
+    """Active topics for one project (DB-backed, process-cached, self-healing).
+
+    On the first read where the DB has no active topics but config.json carries
+    a search_topics[] seed, the seed is mirrored into the DB once and re-read,
+    so adding a project to config.json is enough to make it run. After that the
+    DB is the single living source of truth."""
+    if not name:
+        return []
+    key = name.strip()
+    if key in _CACHE:
+        return _CACHE[key]
+    topics = _fetch_active_topics(key)
+    if not topics and key not in _BOOTSTRAP_ATTEMPTED:
+        _BOOTSTRAP_ATTEMPTED.add(key)
+        if _bootstrap_from_config(key) > 0:
+            topics = _fetch_active_topics(key)
     _CACHE[key] = topics
     return topics
 
 
 def clear_cache() -> None:
     _CACHE.clear()
+    _BOOTSTRAP_ATTEMPTED.clear()
 
 
 if __name__ == "__main__":

package/scripts/twitter_browser.py

@@ -884,8 +884,8 @@ def _like_first_tweet_on_page(page):
         print("[like] clicked like but unlike state not confirmed", file=sys.stderr)
         return {"ok": False, "liked": False, "error": "like_unconfirmed"}
     except Exception as e:
-        print(f"[like] error liking parent tweet: {e}", file=sys.stderr)
-        return {"ok": False, "error": str(e)}
+        print(f"[like] parent tweet not liked (non-fatal): {str(e).splitlines()[0]}", file=sys.stderr)
+        return {"ok": False, "error": str(e).splitlines()[0]}
 
 
 def like_tweet(tweet_url):

package/scripts/twitter_post_plan.py

@@ -667,11 +667,8 @@ def post_one(c: dict, picker_assignment: dict | None = None) -> tuple[str, str]:
             flush=True,
         )
     else:
-        print(
-            f"[like] candidate {cid} parent tweet NOT liked: "
-            f"{like_result.get('error', 'unknown')}",
-            flush=True,
-        )
+        err = str(like_result.get("error", "unknown")).splitlines()[0]
+        print(f"[like] candidate {cid} parent tweet not liked (non-fatal): {err}", flush=True)
 
     if not reply_url or not REPLY_URL_RE.match(reply_url):
         # Reply was likely sent (browser action returned ok=True with verified)