social-autoposter 1.6.78 → 1.6.79

package/mcp/dist/runtime.js

@@ -773,7 +773,12 @@ export async function ensureMenubar() {
     if (fs.existsSync(MENUBAR_ENTRY) &&
         fs.existsSync(MENUBAR_PLIST) &&
         (await menubarLoaded())) {
-        return { ok: true, skipped: true, detail: "already installed" };
+        // Installed — but refresh the stable copy if the bundled menu bar is newer.
+        // An .mcpb update ships new menu bar code, yet the running menu bar runs from
+        // this stable copy (so it survives extension replacement); without this it
+        // would stay the version it first installed at. Cheap: content-compare, and
+        // a kickstart only when something actually changed.
+        return await refreshMenubarIfStale();
     }
     const uv = findUv();
     if (!uv)
@@ -783,3 +788,35 @@ export async function ensureMenubar() {
     };
     return installMenubar(uv, uvEnv, resolvePython());
 }
+// Re-copy the bundled menu bar python into the stable dir when it differs from
+// what's installed, and kickstart the launchd job so the running menu bar picks
+// up the new code. Content-compare keeps this a no-op on an unchanged boot, so
+// it's cheap to call on every ensureMenubar(). This is what makes menu bar
+// changes (e.g. the "Please update now" button) actually ship on an .mcpb update.
+async function refreshMenubarIfStale() {
+    const src = menubarSourceDir();
+    if (!src)
+        return { ok: true, skipped: true, detail: "no bundle source to refresh from" };
+    let changed = false;
+    try {
+        for (const f of fs.readdirSync(src)) {
+            if (!f.endsWith(".py"))
+                continue;
+            const s = fs.readFileSync(path.join(src, f));
+            const dPath = path.join(MENUBAR_DIR, f);
+            const d = fs.existsSync(dPath) ? fs.readFileSync(dPath) : Buffer.alloc(0);
+            if (!s.equals(d)) {
+                fs.writeFileSync(dPath, s);
+                changed = true;
+            }
+        }
+    }
+    catch (e) {
+        return { ok: true, skipped: true, detail: `menu bar refresh check failed: ${e?.message || e}` };
+    }
+    if (!changed)
+        return { ok: true, skipped: true, detail: "menu bar already current" };
+    const uid = process.getuid ? process.getuid() : 0;
+    await sh("launchctl", ["kickstart", "-k", `gui/${uid}/${MENUBAR_LABEL}`], { timeoutMs: 15_000 });
+    return { ok: true, detail: "menu bar refreshed + restarted to bundled version" };
+}

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.78",
-  "installedAt": "2026-06-22T18:51:40.278Z"
+  "version": "1.6.79",
+  "installedAt": "2026-06-22T19:08:46.414Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.6.78",
+  "version": "1.6.79",
   "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

@@ -17,9 +17,12 @@ rather than rumps.notification (which needs a bundle id).
 """
 
 import json
+import os
 import subprocess
 import sys
+import tempfile
 import threading
+import time
 
 import rumps
 
@@ -111,6 +114,14 @@ class S4LMenuBar(rumps.App):
         # read per second.
         self._act_poll = rumps.Timer(self._poll_activity, 1.0)
         self._act_poll.start()
+        # Self-check for a newer published .mcpb, independent of the MCP server's
+        # npm check (which has been flaky). Slow timer + cache; drives the title
+        # indicator + the "Please update now" menu item.
+        self._update_available = False
+        self._latest_version = None
+        self._upd_timer = rumps.Timer(self._check_update, 1800)  # every 30 min
+        self._upd_timer.start()
+        self._check_update(None)
         self._tick(None)
 
     # ---- side effects -----------------------------------------------------
@@ -172,6 +183,98 @@ class S4LMenuBar(rumps.App):
     def _update(self, _=None):
         self._send_to_claude(UPDATE_PROMPT)
 
+    # ---- .mcpb self-update (menu-bar driven) ------------------------------
+    EXT_DIR = os.path.expanduser(
+        "~/Library/Application Support/Claude/Claude Extensions/"
+        "local.mcpb.m13v.social-autoposter"
+    )
+    MCPB_URL = (
+        "https://github.com/m13v/social-autoposter/releases/latest/download/"
+        "social-autoposter.mcpb"
+    )
+    RELEASE_API = (
+        "https://api.github.com/repos/m13v/social-autoposter/releases/latest"
+    )
+
+    @staticmethod
+    def _vtuple(v):
+        try:
+            return tuple(int(x) for x in str(v).split("."))
+        except Exception:
+            return (0,)
+
+    def _check_update(self, _=None):
+        """Is a newer .mcpb published than what's installed? Compare the GitHub
+        latest release tag to the installed extension manifest. Offline / API
+        errors leave the cached value untouched (never flips to 'no update' on a
+        transient failure). A change forces a title + menu repaint."""
+        installed = None
+        try:
+            with open(os.path.join(self.EXT_DIR, "manifest.json")) as f:
+                installed = (json.load(f) or {}).get("version")
+        except Exception:
+            return  # not a .mcpb install (or no manifest) -> nothing to offer
+        try:
+            r = subprocess.run(
+                ["curl", "-fsSL", "-m", "15", self.RELEASE_API],
+                capture_output=True, text=True, timeout=20,
+            )
+            if r.returncode != 0:
+                return
+            latest = ((json.loads(r.stdout) or {}).get("tag_name") or "").lstrip("v")
+        except Exception:
+            return
+        if not latest:
+            return
+        available = bool(installed) and self._vtuple(latest) > self._vtuple(installed)
+        if available != self._update_available or latest != self._latest_version:
+            self._update_available = available
+            self._latest_version = latest
+            self._sig = None  # repaint on next tick
+
+    def _do_mcpb_update(self, _=None):
+        """User clicked 'Please update now'. Pull the latest .mcpb, unpack it over
+        the Desktop extension dir in place, and restart Claude so the new server
+        loads. The menu bar is a launchd process (not a Claude child), so the
+        restart is clean. Heavy work runs on a background thread."""
+        self._notify("S4L", "Updating… Claude will restart in a moment.")
+        threading.Thread(target=self._mcpb_update_work, daemon=True).start()
+
+    def _mcpb_update_work(self):
+        tmpd = tempfile.mkdtemp(prefix="s4l-update-")
+        mcpb = os.path.join(tmpd, "social-autoposter.mcpb")
+        try:
+            r = subprocess.run(["curl", "-fLs", "-m", "300", self.MCPB_URL, "-o", mcpb],
+                               capture_output=True, timeout=320)
+            if r.returncode != 0 or not os.path.exists(mcpb) or os.path.getsize(mcpb) < 100000:
+                self._notify("S4L update failed", "Couldn't download the update — check your connection.")
+                return
+            r = subprocess.run(["unzip", "-oq", mcpb, "-d", self.EXT_DIR],
+                               capture_output=True, timeout=180)
+            if r.returncode != 0:
+                self._notify("S4L update failed", "Couldn't unpack the update.")
+                return
+            # Restart Claude so the refreshed server loads (we're decoupled from it).
+            subprocess.run(["osascript", "-e", 'tell application "Claude" to quit'],
+                           capture_output=True, timeout=20)
+            time.sleep(4)
+            subprocess.run(["killall", "Claude"], capture_output=True)      # if quit was blocked
+            time.sleep(2)
+            subprocess.run(["killall", "-9", "Claude"], capture_output=True)
+            time.sleep(1)
+            subprocess.run(["open", "-a", CLAUDE_APP], capture_output=True, timeout=20)
+            self._update_available = False
+            self._sig = None
+            self._notify("S4L updated", "Claude restarted on the latest version.")
+        except Exception as e:
+            self._notify("S4L update failed", str(e)[:140])
+        finally:
+            try:
+                import shutil
+                shutil.rmtree(tmpd, ignore_errors=True)
+            except Exception:
+                pass
+
     def _open_dashboard(self, _=None):
         url = st.panel_url()
         if url:
@@ -350,6 +453,8 @@ class S4LMenuBar(rumps.App):
         elif not setup_complete and ob and not ob.get("complete"):
             done = sum(1 for m in ob["milestones"] if m.get("status") == "complete")
             self.title = f"S4L {done}/{len(ob['milestones'])}"
+        elif self._update_available:
+            self.title = "S4L ⬆"  # update available — open the menu to update
         else:
             self.title = "S4L"
 
@@ -373,12 +478,11 @@ class S4LMenuBar(rumps.App):
 
         items.append(rumps.separator)
         items.append(rumps.MenuItem("Open dashboard", callback=self._open_dashboard))
-        if snap.get("update_available") and snap.get("latest_version"):
+        if self._update_available and self._latest_version:
+            items.append(rumps.separator)
+            items.append(self._label(f"⬆ Update available · v{self._latest_version}"))
             items.append(
-                rumps.MenuItem(
-                    f"Update to v{snap['latest_version']} in Claude",
-                    callback=self._update,
-                )
+                rumps.MenuItem("Please update now", callback=self._do_mcpb_update)
             )
         items.append(rumps.MenuItem("Quit", callback=rumps.quit_application))
 

package/mcp/package.json

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