social-autoposter 1.6.134 → 1.6.136

package/mcp/dist/index.js

@@ -2607,66 +2607,63 @@ async function ensureMemorySnapshotInstalled() {
         return { ok: false, detail: e?.message || String(e) };
     }
 }
-// The CURRENT Claude account's session id, from config.json's per-session
-// `dxt:allowlistLastUpdated:<id>` keys (most-recent = live session; matches this
-// MCP's own start time). Lets us read the schedule for the ACTUAL logged-in
-// account instead of guessing. Mirrors s4l_menubar.py::_active_session_id.
-function activeSessionId() {
-    try {
-        const p = path.join(os.homedir(), "Library", "Application Support", "Claude", "config.json");
-        const d = JSON.parse(fs.readFileSync(p, "utf-8"));
-        let bestId = null;
-        let bestTs = "";
-        for (const [k, v] of Object.entries(d)) {
-            if (k.startsWith("dxt:allowlistLastUpdated:") && typeof v === "string" && v > bestTs) {
-                bestTs = v;
-                bestId = k.slice("dxt:allowlistLastUpdated:".length);
-            }
-        }
-        return bestId;
-    }
-    catch {
-        return null;
-    }
-}
-// The ACTUAL schedule state for the current account (read, not inferred from
-// firing): 'missing' | 'disabled' | 'ok' | 'unknown'. Drives the dashboard's
-// "Set up draft schedule" button. Mirrors s4l_menubar.py::_schedule_state.
+// Is the draft schedule registered AND running for the LIVE account?
+//   'ok'       — worker tasks present+enabled and FIRING (lastRunAt within
+//                SCHEDULE_FIRING_MS) — the host is actively running them.
+//   'disabled' — present but a worker task is disabled.
+//   'missing'  — not firing anywhere (orphaned / not registered for the live
+//                account) -> dashboard offers "Set up draft schedule".
+// The live account is identified by the registry the host is actually FIRING
+// (freshest lastRunAt — only the active account's scheduler advances it), NOT a
+// session id (which churns on every Claude restart and mis-read "missing" while
+// the tasks were firing). Mirrors s4l_menubar.py::_schedule_state.
+const SCHEDULE_FIRING_MS = 420_000; // 7 min; tolerates throttle + restart gaps
 function scheduleState() {
-    const sid = activeSessionId();
-    if (!sid)
-        return "unknown";
-    let regPath = null;
+    let newestMs = null;
+    let newestEnabled = false;
+    let anyPresent = false;
+    let anyEnabled = false;
     try {
         const base = path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions");
         for (const ws of fs.readdirSync(base)) {
-            const cand = path.join(base, ws, sid, "scheduled-tasks.json");
-            if (fs.existsSync(cand)) {
-                regPath = cand;
-                break;
+            for (const inner of fs.readdirSync(path.join(base, ws))) {
+                const reg = path.join(base, ws, inner, "scheduled-tasks.json");
+                let d;
+                try {
+                    d = JSON.parse(fs.readFileSync(reg, "utf-8"));
+                }
+                catch {
+                    continue;
+                }
+                const byId = {};
+                for (const t of d.scheduledTasks || [])
+                    byId[t.id] = t;
+                const recs = QUEUE_WORKERS.map((s) => byId[s.taskId]);
+                if (recs.some((r) => !r))
+                    continue;
+                anyPresent = true;
+                const enabled = recs.every((r) => r.enabled);
+                anyEnabled = anyEnabled || enabled;
+                const epochs = recs
+                    .map((r) => Date.parse(r.lastRunAt || ""))
+                    .filter((n) => !Number.isNaN(n));
+                const e = epochs.length ? Math.max(...epochs) : null;
+                if (e !== null && (newestMs === null || e > newestMs)) {
+                    newestMs = e;
+                    newestEnabled = enabled;
+                }
             }
         }
     }
     catch {
-        /* base missing */
-    }
-    if (!regPath)
-        return "missing";
-    try {
-        const d = JSON.parse(fs.readFileSync(regPath, "utf-8"));
-        const byId = {};
-        for (const t of d.scheduledTasks || [])
-            byId[t.id] = t;
-        const recs = QUEUE_WORKERS.map((s) => byId[s.taskId]);
-        if (recs.some((r) => !r))
-            return "missing";
-        if (recs.some((r) => !r.enabled))
-            return "disabled";
-        return "ok";
+        /* base missing -> treat as missing */
     }
-    catch {
-        return "missing";
+    if (newestMs !== null && Date.now() - newestMs <= SCHEDULE_FIRING_MS) {
+        return newestEnabled ? "ok" : "disabled";
     }
+    if (anyPresent && !anyEnabled)
+        return "disabled";
+    return "missing";
 }
 // Assemble everything the panel needs in one shot (projects + X + autopilot +
 // version). Resilient: any probe that throws degrades to a safe default rather

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.134",
-  "installedAt": "2026-06-29T02:17:51.544Z"
+  "version": "1.6.136",
+  "installedAt": "2026-06-29T04:09:39.530Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.134",
+  "version": "1.6.136",
   "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_menubar.py

@@ -133,6 +133,12 @@ REARM_PROMPT = (
 # scheduler's per-minute cadence + a slow claim.
 AUTOPILOT_STALL_SECONDS = 180
 
+# A worker task whose lastRunAt is within this many seconds is "firing" — the host
+# scheduler runs them every minute, so a fresh stamp means the live account's
+# schedule is active. 7 min tolerates host throttling + a restart gap without
+# false "not scheduled". Used by _schedule_state.
+FIRING_WINDOW = 420
+
 
 def _glyph(status):
     return GLYPH.get(status, "·")
@@ -236,9 +242,14 @@ class S4LMenuBar(rumps.App):
         # indicator + the "Please update now" menu item.
         self._update_available = False
         self._latest_version = None
-        self._upd_timer = rumps.Timer(self._check_update, 60)  # every 1 min
+        # Poll every 15 min, NOT every 60s. _check_update hits GitHub's
+        # releases/latest UNAUTHENTICATED (60 req/hr per IP); a 60s poll = 60/hr,
+        # right at the cap, so it got 403-rate-limited and silently stopped
+        # detecting updates (the "update available" badge never showed). 15 min =
+        # 4/hr leaves ample headroom; updates aren't urgent enough to poll faster.
+        self._upd_timer = rumps.Timer(self._check_update, 900)
         self._upd_timer.start()
-        self._check_update(None)
+        self._check_update(None)  # one check at launch (badge appears ~immediately)
         # One-shot self-heal: if the autopilot scheduled tasks are running in the
         # wrong folder (or the deprecated single autopilot task still exists),
         # relocate them to ~/.s4l-worker so their once-a-minute runs stop polluting
@@ -351,76 +362,80 @@ class S4LMenuBar(rumps.App):
         do NOT auto-type (focus/timing flaky) and do NOT write the registry directly
         (can't reliably target a just-switched-into account)."""
         copied = self._copy_to_clipboard(REARM_PROMPT)
+        # Show the modal BEFORE opening Claude. If we raise Claude first, the NSAlert
+        # renders BEHIND it (invisible) while still blocking the main thread, which
+        # is what made the menu look frozen/greyed with no visible dialog. Showing
+        # it first keeps it frontmost; we open Claude after the user dismisses it.
+        # (_notify's osascript notification silently no-ops from this bundle-less
+        # launchd process, so a modal is the only reliable feedback.)
+        msg = (
+            "The setup prompt is copied to your clipboard.\n\nClick OK, then click into "
+            "the Claude chat, paste it (Cmd+V), and press Enter — that schedules the "
+            "draft tasks for this account."
+            if copied
+            else "Click OK, then open Claude and ask it to set up the draft schedule for this account."
+        )
+        try:
+            rumps.alert(title="Set up the draft schedule", message=msg, ok="OK")
+        except Exception:
+            self._notify("S4L · setup prompt copied" if copied else "S4L",
+                         "Paste the prompt into Claude (Cmd+V) and press Enter.")
         self._open_claude()
-        if copied:
-            self._notify(
-                "S4L · setup prompt copied",
-                "Paste it into Claude (⌘V) and press Enter to schedule the draft "
-                "tasks for this account.",
-            )
-        else:
-            self._notify(
-                "S4L",
-                "Open Claude and ask it to set up the draft schedule for this account.",
-            )
 
-    # ---- schedule-state detection (reads the ACTUAL schedule, reliably) ----
-    def _active_session_id(self):
-        """The CURRENT account's session id, from config.json's per-session
-        `dxt:allowlistLastUpdated:<id>` keys — the most-recently-updated one is the
-        live session (it matches the MCP's own start time to the ms). This is what
-        lets us read the schedule for the ACTUAL logged-in account instead of
-        guessing a folder by mtime. None if undeterminable."""
+    # ---- schedule-state detection ----------------------------------------
+    # Identify the LIVE account's registry by which one the host is actually
+    # FIRING (freshest lastRunAt — only the active account's scheduler advances
+    # it), then read THAT registry's enabled state. This is robust across the
+    # session-id churn that restarts cause; the old "active session = newest
+    # config.json allowlist key" heuristic mis-reported "missing" after a restart
+    # even while the tasks were firing.
+    @staticmethod
+    def _iso_to_epoch(s):
+        if not s:
+            return None
         try:
-            p = os.path.join(os.path.expanduser("~"), "Library", "Application Support",
-                             "Claude", "config.json")
-            with open(p) as fh:
-                d = json.load(fh)
-            best_id, best_ts = None, ""
-            for k, v in d.items():
-                if k.startswith("dxt:allowlistLastUpdated:") and isinstance(v, str):
-                    if v > best_ts:  # ISO-8601 sorts lexically by time
-                        best_ts, best_id = v, k.split(":", 2)[2]
-            return best_id
+            import calendar
+            return calendar.timegm(
+                time.strptime(str(s).strip().rstrip("Z").split(".")[0], "%Y-%m-%dT%H:%M:%S")
+            )
         except Exception:
             return None
 
-    def _active_session_registry_path(self):
-        """Path to the current account's scheduled-tasks.json (claude-code-sessions/
-        <workspace>/<active-session>/...). None if the active session can't be found
-        or its dir doesn't exist yet (brand-new account -> schedule absent)."""
-        sid = self._active_session_id()
-        if not sid:
-            return None
-        hits = glob.glob(os.path.join(
-            os.path.expanduser("~"), "Library", "Application Support", "Claude",
-            "claude-code-sessions", "*", sid, "scheduled-tasks.json"))
-        return hits[0] if hits else None
-
     def _schedule_state(self):
-        """Read the ACTUAL schedule for the current account (not inferred from
-        whether it fired — 'not fired' != 'not scheduled'):
-          'missing'  — no registry / a worker task absent for this account
-          'disabled' — both present but at least one enabled=false
-          'ok'       — both worker tasks present and enabled
-          'unknown'  — couldn't determine the active session (degrade gracefully)"""
-        if not self._active_session_id():
-            return "unknown"
-        path = self._active_session_registry_path()
-        if not path:
-            return "missing"
-        try:
-            with open(path) as fh:
-                d = json.load(fh)
-        except Exception:
-            return "missing"
-        by_id = {t.get("id"): t for t in (d.get("scheduledTasks") or [])}
-        recs = [by_id.get(tid) for tid in WORKER_TASK_IDS]
-        if any(r is None for r in recs):
-            return "missing"
-        if any(not r.get("enabled") for r in recs):
+        """Is the draft schedule registered AND running for the live account?
+          'ok'       — worker tasks present+enabled and FIRING (lastRunAt within
+                       FIRING_WINDOW) — the host is actively running them.
+          'disabled' — present but a worker task is disabled.
+          'missing'  — not firing anywhere (orphaned / not registered for the live
+                       account) -> offer re-arm.
+        The active account is identified by the freshest-firing registry, NOT a
+        session id (which churns on restart)."""
+        newest_epoch, newest_enabled = None, False
+        any_present, any_enabled = False, False
+        for f in glob.glob(SCHED_REGISTRY_GLOB):
+            try:
+                with open(f) as fh:
+                    d = json.load(fh)
+            except Exception:
+                continue
+            by_id = {t.get("id"): t for t in (d.get("scheduledTasks") or [])}
+            recs = [by_id.get(tid) for tid in WORKER_TASK_IDS]
+            if any(r is None for r in recs):
+                continue
+            any_present = True
+            enabled = all(r.get("enabled") for r in recs)
+            any_enabled = any_enabled or enabled
+            epochs = [self._iso_to_epoch(r.get("lastRunAt")) for r in recs]
+            e = max([x for x in epochs if x is not None], default=None)
+            if e is not None and (newest_epoch is None or e > newest_epoch):
+                newest_epoch, newest_enabled = e, enabled
+        # Firing recently => the live account's schedule is active and healthy.
+        if newest_epoch is not None and (time.time() - newest_epoch) <= FIRING_WINDOW:
+            return "ok" if newest_enabled else "disabled"
+        # Not firing anywhere. Registered-but-disabled => disabled; else missing.
+        if any_present and not any_enabled:
             return "disabled"
-        return "ok"
+        return "missing"
 
     # ---- autopilot liveness (the false-green fix) -------------------------
     def _autopilot_stalled(self):
@@ -998,21 +1013,17 @@ class S4LMenuBar(rumps.App):
         blocker = (ob or {}).get("current_blocker")
         blocker_code = (blocker or {}).get("code")
         # --- Autopilot health (only meaningful once setup is complete) --------
-        # PRIMARY signal: read the ACTUAL schedule for the CURRENT account
-        # (missing/disabled/ok) — reliable, NOT inferred from whether it fired
-        # ("not fired" != "not scheduled"). SECONDARY: if scheduled+enabled but
-        # still not draining, work out why (rate-limit vs other).
+        # SINGLE signal: is the draft schedule registered AND firing for the live
+        # account (schedule_state)? 'ok' = the host is running the tasks -> healthy,
+        # NO warning (even if no draft has drained yet — that's just an empty queue
+        # between cycles, not a setup problem). 'missing'/'disabled' = not running
+        # for this account -> show re-arm. We deliberately do NOT drive the menu off
+        # the drain-status latch anymore: it stayed stale after recovery and made a
+        # firing, healthy autopilot look "not set up".
         schedule_state = self._schedule_state() if setup_complete else "ok"
-        stalled = setup_complete and self._autopilot_stalled()
         self._schedule_state_cache = schedule_state
-        # Stall reason only matters when the schedule IS on but drafts still aren't
-        # draining (rate-limit / other) — not when it's simply unscheduled.
-        self._stall_reason_info = (
-            self._stall_reason() if (stalled and schedule_state in ("ok", "unknown")) else ("", "")
-        )
-        # Any non-healthy state drops the stale "drafting" spinner so the ⚠ in the
-        # title isn't masked (see _poll_activity).
-        attention = setup_complete and (schedule_state in ("missing", "disabled") or stalled)
+        attention = setup_complete and schedule_state in ("missing", "disabled")
+        # Drop the stale "drafting" spinner while we need attention so the ⚠ shows.
         self._stalled = attention
 
         # Spinner owns the title while busy; _spin already keeps the ⬆ visible there.
@@ -1026,32 +1037,19 @@ class S4LMenuBar(rumps.App):
                 blocker.get("message", "Setup is blocked"),
             )
         self._last_blocker_code = blocker_code
-        # Notify once per episode, naming the actual problem + the right action.
+        # Notify once per episode (the draft schedule isn't running for this account).
         if attention and not self._stall_notified:
-            kind, detail = self._stall_reason_info
-            if schedule_state == "missing":
-                self._notify(
-                    "S4L draft autopilot not scheduled",
-                    "No draft tasks are scheduled on this Claude account (switching "
-                    "accounts clears them). Open the S4L menu → “Set up draft schedule”.",
-                )
-            elif schedule_state == "disabled":
+            if schedule_state == "disabled":
                 self._notify(
                     "S4L draft tasks disabled",
                     "The draft tasks are scheduled but disabled. Open the S4L menu → "
                     "“Set up draft schedule” to re-enable.",
                 )
-            elif kind == "rate_limited":
-                self._notify(
-                    "S4L autopilot paused",
-                    "Claude usage limit reached" + (f" ({detail})" if detail else "")
-                    + ". Drafting resumes at reset, or sign into an account with quota.",
-                )
             else:
                 self._notify(
-                    "S4L autopilot stalled",
-                    "Drafts aren't being produced though the schedule is on. Open the "
-                    "S4L menu for options.",
+                    "S4L draft autopilot not scheduled",
+                    "No draft tasks are running on this Claude account (switching "
+                    "accounts clears them). Open the S4L menu → “Set up draft schedule”.",
                 )
             self._stall_notified = True
         elif not attention:
@@ -1338,29 +1336,16 @@ class S4LMenuBar(rumps.App):
         items.append(header)
         items.append(rumps.separator)
 
-        # Autopilot needs attention: surface the right action FIRST, above the
-        # normal state items. PRIMARY driver = the actual schedule state for THIS
-        # account (missing/disabled) — that's what "Set up draft schedule" fixes
-        # (host create_scheduled_task). Only when the schedule IS on but drafts
-        # aren't draining do we fall to the stall-reason wording (rate-limit/other),
-        # where re-creating the schedule wouldn't help.
+        # Attention = the draft schedule isn't running for THIS account (missing or
+        # disabled). "Set up draft schedule" fixes it via host create_scheduled_task.
+        # When the schedule IS firing (ok), attention is False and nothing shows here
+        # — a firing autopilot reads as healthy even if no draft has drained yet.
         if attention:
-            if schedule_state == "missing":
-                items.append(self._label("⚠ Draft tasks aren’t scheduled on this account"))
-                items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
-            elif schedule_state == "disabled":
+            if schedule_state == "disabled":
                 items.append(self._label("⚠ Draft tasks are scheduled but disabled"))
-                items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             else:
-                kind, detail = self._stall_reason_info
-                if kind == "rate_limited":
-                    items.append(self._label("⚠ Autopilot paused — Claude usage limit"))
-                    if detail:
-                        items.append(self._label(f"   {detail}"))
-                    items.append(self._label("   Resumes at reset, or switch Claude account"))
-                else:
-                    items.append(self._label("⚠ Scheduled, but no drafts are being produced"))
-                    items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
+                items.append(self._label("⚠ Draft tasks aren’t scheduled on this account"))
+            items.append(rumps.MenuItem("Set up draft schedule for this account", callback=self._rearm))
             items.append(rumps.separator)
 
         if not runtime_ready:

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.134",
+  "version": "1.6.136",
   "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.134",
+  "version": "1.6.136",
   "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"