social-autoposter 1.6.78 → 1.6.80

package/mcp/dist/index.js

@@ -183,17 +183,21 @@ const server = new McpServer({
         "autopilot by calling the HOST tool `create_scheduled_task` with: taskId " +
         "'social-autoposter-autopilot'; cronExpression '* * * * *' (continuous, like the pipeline; the " +
         "host runs one at a time and skips overlapping fires, so cycles run back-to-back); and a " +
-        "self-contained prompt telling the run to call scan_candidates (which long-polls — if it " +
-        "returns a `Scan in progress` status, call scan_candidates again with the same args and keep " +
-        "re-calling until it returns candidates; never sleep or use background waits between calls), " +
-        "then (if it needs the project's brand voice to draft on-brand) call project_config to read it, " +
-        "draft ONE on-brand reply (<=250 chars, same language as the thread, adds real value) for each " +
-        "candidate worth engaging, then call submit_drafts with those drafts, and NOT post (drafts pile " +
-        "up in the menu-bar approval cards for the user to approve). The prompt MUST name EVERY tool the " +
-        "run can use (scan_candidates, project_config, submit_drafts) so none is a surprise mid-run. " +
-        "Then run ONE FULL cycle yourself now that exercises ALL of them " +
-        "(scan_candidates -> project_config -> draft -> submit_drafts) to seed the cards AND pre-approve " +
-        "every tool, so unattended fires never stall waiting on a per-tool permission prompt. If the host " +
+        "self-contained prompt telling the run to use ONLY two tools — scan_candidates and submit_drafts " +
+        "— and to IMPROVISE NOTHING ELSE. Specifically the prompt must say: (1) call scan_candidates " +
+        "(which long-polls — if it returns a `Scan in progress` status, call scan_candidates again with " +
+        "the same args and keep re-calling until it returns candidates; never sleep or use background " +
+        "waits between calls); (2) the brand voice + guardrails come back INLINE in the result's " +
+        "`project_voices[<matched_project>]` field — draft from THAT and NEVER read config files, call " +
+        "project_config, or run Bash/Read to find the voice; (3) draft ONE on-brand reply (<=250 chars, " +
+        "same language as the thread, adds real value) for each candidate worth engaging; (4) call " +
+        "submit_drafts with those drafts, and do NOT post (drafts pile up in the menu-bar approval cards). " +
+        "Add a HARD GUARD: if scan_candidates is NOT available (ToolSearch returns no matching tool — can " +
+        "happen when a run spawns before the extension's MCP server reconnects), STOP immediately and " +
+        "report 'S4L tools unavailable, skipping this cycle' — do NOT search the connector registry, do " +
+        "NOT call list_connectors, do NOT improvise any other tool. Then run ONE cycle yourself now " +
+        "(scan_candidates -> draft -> submit_drafts) to seed the cards AND pre-approve those two tools, " +
+        "so unattended fires never stall waiting on a per-tool permission prompt. If the host " +
         "exposes no create_scheduled_task tool, tell the user " +
         "the autopilot could not be scheduled here and to run a draft cycle manually instead.\n\n" +
         "BE PROACTIVE ABOUT MARKETING MOMENTS. Whenever the user ships, finishes, merges, or releases " +
@@ -1838,18 +1842,61 @@ function startScanJob(project) {
     });
     return job;
 }
+// Read the on-brand drafting guidance for the given projects from config.json so
+// scan_candidates can hand it to the agent INLINE. Without this the autopilot run
+// has to read the config itself (project_config returns status, not the voice
+// fields) — and a headless run improvises Bash/Read for that, hitting an
+// un-approved tool and hanging. Returning the voice here removes the need to read
+// any file. Best-effort: a missing/unreadable config yields {} and the agent
+// drafts from thread context, same as before.
+function readProjectVoices(projectNames) {
+    const out = {};
+    const want = new Set(projectNames.filter(Boolean));
+    if (!want.size)
+        return out;
+    try {
+        const cfg = JSON.parse(fs.readFileSync(path.join(repoDir(), "config.json"), "utf-8"));
+        const projects = Array.isArray(cfg?.projects) ? cfg.projects : [];
+        for (const p of projects) {
+            if (!p?.name || !want.has(p.name))
+                continue;
+            // Only the fields needed to draft on-brand — keep it lean.
+            out[p.name] = {
+                voice: p.voice,
+                voice_relationship: p.voice_relationship,
+                description: p.description,
+                differentiator: p.differentiator,
+                content_guardrails: p.content_guardrails,
+                website: p.website,
+                get_started_link: p.get_started_link,
+            };
+        }
+    }
+    catch {
+        /* best effort — no inline voice, agent falls back to thread context */
+    }
+    return out;
+}
 function formatScanResult(scan) {
     if (!scan.batchId) {
         return textContent(scan.blocked || "No candidates found.");
     }
+    // The brand voice for every project in this batch, INLINE, so the agent never
+    // has to read a config file (that improvisation is what hangs headless runs).
+    const projects = Array.from(new Set(scan.candidates.map((c) => c.matched_project).filter(Boolean)));
+    const project_voices = readProjectVoices(projects);
     return jsonContent({
         batch_id: scan.batchId,
         count: scan.candidates.length,
         candidates: scan.candidates,
+        project_voices,
         next_step: `Draft an on-brand reply (<=250 chars, match the thread's language) for each candidate you ` +
-            `judge genuinely worth engaging; skip the rest. Then call submit_drafts with batch_id ` +
-            `"${scan.batchId}" and one entry per drafted reply ({candidate_id, reply_text}). Nothing posts ` +
-            `until the user approves.`,
+            `judge genuinely worth engaging; skip the rest. The brand voice + guardrails for each ` +
+            `candidate's project are in project_voices[<matched_project>] (voice, description, ` +
+            `differentiator, content_guardrails) — draft from THAT. Do NOT read config files or call any ` +
+            `other tool to find the voice; everything you need is in this result. Then call submit_drafts ` +
+            `with batch_id "${scan.batchId}" and one entry per drafted reply ({candidate_id, reply_text}). ` +
+            `Nothing posts until the user approves.`,
     });
 }
 function scanInProgress(job) {
@@ -1867,7 +1914,10 @@ tool("scan_candidates", {
         "and without spending any `claude -p` budget. You (this session) then draft an on-brand reply " +
         "for each good candidate YOURSELF and submit them with `submit_drafts`. Each candidate includes " +
         "its candidate_id (pass it back), the thread text/author, the matched project, and engagement " +
-        "metrics. Optional `project` scopes the scan to one configured project. The scan drives a real " +
+        "metrics. The result ALSO includes `project_voices` — the brand voice + guardrails for each " +
+        "project in the batch — so you draft on-brand WITHOUT reading config files or calling other " +
+        "tools (do not improvise a config read). Optional `project` scopes the scan to one configured " +
+        "project. The scan drives a real " +
         "browser and can take 1-3 minutes: this call long-polls and may return a `Scan in progress` " +
         "status instead of candidates — if so, just call scan_candidates again (same args) and keep " +
         "re-calling until it returns candidates. Never sleep or use a background wait to bridge the gap.",

package/mcp/dist/runtime.js

@@ -178,6 +178,7 @@ export function ensurePipelineCurrent() {
         const rt = readRuntime();
         if (rt?.pipeline_version === bundled)
             return; // already current.
+        const prevVer = rt?.pipeline_version ?? "unrecorded"; // capture before we mutate rt below.
         // Stale (or never recorded): extract the new pipeline OVER the materialized
         // repo. No rmSync, so config.json + logs are preserved.
         fs.mkdirSync(REPO_MATERIALIZE_DIR, { recursive: true });
@@ -199,7 +200,7 @@ export function ensurePipelineCurrent() {
                 /* best effort — worst case we re-extract next boot */
             }
         }
-        console.error(`[runtime] re-materialized pipeline -> ${bundled} (was ${rt?.pipeline_version ?? "unrecorded"})`);
+        console.error(`[runtime] re-materialized pipeline -> ${bundled} (was ${prevVer})`);
     }
     catch (e) {
         console.error(`[runtime] ensurePipelineCurrent error: ${e?.message || e}`);
@@ -773,7 +774,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 +789,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.80",
+  "installedAt": "2026-06-22T19:14:04.032Z"
 }

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.80",
   "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.80",
   "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.80",
   "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"