social-autoposter 1.6.82 → 1.6.84

package/mcp/dist/index.js

@@ -22,7 +22,7 @@ import { xStatus, xConnect, xDetectSources, xScanProfile, summarizeXAuth } from
 import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, ensurePipelineCurrent, } from "./runtime.js";
 import { blockOnboardingMilestone, completeOnboardingMilestone, ensureDoctorPhase, onboardingLedger, onboardingSnapshot, recordOnboardingAttempt, runDoctorPhase, } from "./onboarding.js";
 import { VERSION, versionStatus, latestPublishedVersion } from "./version.js";
-import { initSentry, sendHeartbeat, captureError, flushSentry } from "./telemetry.js";
+import { initSentry, sendHeartbeat, captureError, flushSentry, startLogStreaming, flushLogs } from "./telemetry.js";
 import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE, getUiCapability, } from "@modelcontextprotocol/ext-apps/server";
 import { fileURLToPath } from "node:url";
 import http from "node:http";
@@ -576,10 +576,20 @@ async function postApproved(batchId, plan) {
     catch {
         /* keep raw */
     }
-    // On a successful run, mark the posted candidates in the ORIGINAL plan so the
-    // other review surface (chat vs menu-bar pop-ups) skips them — cross-surface
-    // de-dup. Best-effort; the pipeline's own already-posted check is the backstop.
-    if (res.code === 0) {
+    // Real posted count from the pipeline summary — NOT the approved count. A run
+    // can exit 0 yet post nothing (every reply hit reply_box_not_found, etc.), so
+    // trusting approved.length here reported phantom successes ("posted: 1" when 0
+    // landed). Fall back to approved.length only when the summary is unparseable
+    // AND the process exited clean.
+    const summObj = (summary && typeof summary === "object") ? summary : null;
+    const realPosted = summObj && typeof summObj.posted === "number"
+        ? summObj.posted
+        : res.code === 0 && !summObj
+            ? approved.length
+            : 0;
+    // Mark only candidates that ACTUALLY posted (cross-surface de-dup). When the
+    // summary is missing but the run exited clean, fall back to marking all.
+    if (realPosted > 0 || (res.code === 0 && !summObj)) {
         for (const c of approved)
             c.posted = true;
         try {
@@ -589,8 +599,27 @@ async function postApproved(batchId, plan) {
             /* best effort */
         }
     }
+    // Post failures are HANDLED in the pipeline (it returns a count, never throws),
+    // so they never reach Sentry on their own. Capture an explicit event whenever
+    // the run exited non-zero OR fewer drafts posted than were approved. This is
+    // the only telemetry channel that reaches a customer .mcpb install (their cycle
+    // log lives on their machine). install_id/hostname are auto-tagged.
+    if (res.code !== 0 || realPosted < approved.length) {
+        captureError(new Error(`post_drafts: ${realPosted}/${approved.length} posted (exit=${res.code})`), {
+            component: "post",
+            exit_code: String(res.code),
+            attempted: String(approved.length),
+            posted: String(realPosted),
+            failure_reasons: String(summObj?.failure_reasons || ""),
+            skip_reasons: String(summObj?.skip_reasons || ""),
+            stderr_tail: res.stderr.split("\n").slice(-5).join(" | ").slice(0, 500),
+        });
+        void flushSentry(2000);
+    }
+    void flushLogs();
     return {
         attempted: approved.length,
+        posted: realPosted,
         exit_code: res.code,
         summary,
         stderr_tail: res.stderr.split("\n").slice(-8).join("\n"),
@@ -1210,11 +1239,20 @@ tool("post_drafts", {
         });
     }
     const result = await postApproved(batch_id, plan);
+    // Report the REAL posted count from the pipeline, not the approved count.
+    // A run can approve N yet land 0 (browser/session failure); reporting
+    // approve.size here told the agent "posted: N" on a total failure.
+    const actuallyPosted = typeof result.posted === "number" ? result.posted : approve.size;
+    if (actuallyPosted < approve.size) {
+        warnings.push(`only ${actuallyPosted}/${approve.size} actually posted (exit=${result.exit_code}); ` +
+            `see result.summary / result.stderr_tail for the reason`);
+    }
     return jsonContent({
         batch_id,
         drafted: total,
-        posted: approve.size,
-        skipped: total - approve.size,
+        posted: actuallyPosted,
+        approved: approve.size,
+        skipped: total - actuallyPosted,
         edited: editedCount,
         result,
         warnings,
@@ -2346,6 +2384,11 @@ registerAppResource(server, "S4L product link", PRODUCT_LINK_URI, { mimeType: RE
 }));
 async function main() {
     initSentry();
+    // Tee the verbatim stdout/stderr of every pipeline subprocess to the s4l
+    // backend so we can troubleshoot/rescue any user scenario (silent stalls,
+    // partial onboarding) without asking them to ship a log file. Best-effort;
+    // disabled with SAPS_LOG_STREAM=0.
+    startLogStreaming();
     // A plugin UPDATE refreshes this server (dist/) but not the materialized
     // pipeline. Re-extract the bundled pipeline.tgz when it's newer than what's on
     // disk, BEFORE serving, so the very first scan uses the shipped pipeline (not
@@ -2369,8 +2412,22 @@ async function main() {
     // and cheap when already present, so existing installs pick it up on the next
     // Claude restart without re-provisioning. Best-effort: never blocks boot.
     void ensureMenubar()
-        .then((r) => console.error(`[social-autoposter-mcp] menubar: ${r.skipped ? "skip" : r.ok ? "ok" : "fail"} (${r.detail})`))
-        .catch((e) => console.error("[social-autoposter-mcp] menubar ensure failed:", e?.message || e));
+        .then((r) => {
+        console.error(`[social-autoposter-mcp] menubar: ${r.skipped ? "skip" : r.ok ? "ok" : "fail"} (${r.detail})`);
+        // A non-skipped failure here is the boot-time "menu bar didn't come up"
+        // path (e.g. uv missing, rumps reinstall failed on an existing install).
+        // Report it; a skip (non-macOS / runtime not ready) is expected, not an error.
+        if (!r.ok && !r.skipped) {
+            captureError(new Error(`menubar ensure failed: ${r.detail}`), {
+                component: "menubar",
+                phase: "ensure",
+            });
+        }
+    })
+        .catch((e) => {
+        console.error("[social-autoposter-mcp] menubar ensure failed:", e?.message || e);
+        captureError(e, { component: "menubar", phase: "ensure" });
+    });
     // Phone home so this .mcpb install is visible in the install-lane digest
     // (parity with the npx launchd heartbeat). Once on startup, then every 15m
     // while the desktop app keeps the server alive. unref() so it never holds the
@@ -2382,6 +2439,7 @@ async function main() {
 main().catch(async (err) => {
     console.error("[social-autoposter-mcp] fatal:", err);
     captureError(err, { component: "main" });
+    await flushLogs();
     await flushSentry();
     process.exit(1);
 });

package/mcp/dist/repo.js

@@ -30,6 +30,27 @@ export function repoDir() {
 // "No drafts in batch ...". Default to /tmp to match the script; allow an explicit
 // override for non-standard installs.
 export const TMP_DIR = process.env.SAPS_TMP_DIR || "/tmp";
+let lineSink = null;
+export function setLineSink(fn) {
+    lineSink = fn;
+}
+// Derive a short, stable context label for a spawned command so log lines can
+// be grouped by which script produced them (e.g. "scripts/seed_search_topics.py",
+// "skill/run-twitter-cycle.sh"). Best-effort; never throws.
+function deriveContext(cmd, args) {
+    try {
+        const base = cmd.split("/").pop() || cmd;
+        if (/python/i.test(base) || base === "bash" || base === "sh" || base === "node") {
+            const first = args.find((a) => !a.startsWith("-"));
+            if (first)
+                return first;
+        }
+        return [base, args[0] ?? ""].join(" ").trim();
+    }
+    catch {
+        return cmd;
+    }
+}
 // Spawn a process inside the repo, inheriting the repo env (API base + keys
 // come from the install's environment / .env loaded by the scripts themselves).
 //
@@ -73,6 +94,29 @@ export function run(cmd, args, opts = {}) {
             }
             return buf;
         };
+        // Parallel whole-line splitter that tees to the telemetry sink (if any),
+        // kept separate from the onLine pump so neither path can affect the other.
+        const logCtx = opts.logContext || deriveContext(cmd, args);
+        let sinkOutBuf = "";
+        let sinkErrBuf = "";
+        const sinkPump = (chunk, which, buf) => {
+            const sink = lineSink;
+            if (!sink)
+                return buf;
+            buf += chunk;
+            let nl;
+            while ((nl = buf.indexOf("\n")) !== -1) {
+                const line = buf.slice(0, nl);
+                buf = buf.slice(nl + 1);
+                try {
+                    sink(line, which, logCtx);
+                }
+                catch {
+                    /* the telemetry sink must never break the wrapped command */
+                }
+            }
+            return buf;
+        };
         let timer;
         if (opts.timeoutMs) {
             timer = setTimeout(() => {
@@ -83,11 +127,13 @@ export function run(cmd, args, opts = {}) {
             const s = d.toString();
             stdout += s;
             outBuf = pump(s, "stdout", outBuf);
+            sinkOutBuf = sinkPump(s, "stdout", sinkOutBuf);
         });
         child.stderr.on("data", (d) => {
             const s = d.toString();
             stderr += s;
             errBuf = pump(s, "stderr", errBuf);
+            sinkErrBuf = sinkPump(s, "stderr", sinkErrBuf);
         });
         child.on("close", (code) => {
             if (timer)
@@ -109,6 +155,23 @@ export function run(cmd, args, opts = {}) {
                         /* ignore */
                     }
             }
+            const sink = lineSink;
+            if (sink) {
+                if (sinkOutBuf)
+                    try {
+                        sink(sinkOutBuf, "stdout", logCtx);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                if (sinkErrBuf)
+                    try {
+                        sink(sinkErrBuf, "stderr", logCtx);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+            }
             resolve({ code: code ?? -1, stdout, stderr });
         });
         child.on("error", (err) => {

package/mcp/dist/runtime.js

@@ -22,6 +22,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { captureError } from "./telemetry.js";
 // Pin the standalone CPython series the venv is built from. Bump deliberately.
 const PYTHON_VERSION = "3.12";
 // The CDP scan engine the twitter cycle shells out to (~/.local/bin/browser-harness).
@@ -378,6 +379,15 @@ async function provision(progress) {
         progress.ok = false;
         progress.error = msg;
         writeProgress(progress);
+        // Every fatal install-step failure (repo unpack, uv, python, venv, deps,
+        // chromium, harness, chrome) was previously only written to the local
+        // install-progress.json, invisible to us. Report it so a failed runtime
+        // install becomes a real Sentry event, tagged with the step that failed.
+        const failedStep = progress.steps.find((s) => s.status === "running");
+        captureError(new Error(msg), {
+            component: "install",
+            ...(failedStep ? { step: failedStep.id } : {}),
+        });
         return progress;
     };
     fs.mkdirSync(RUNTIME_DIR, { recursive: true });
@@ -499,6 +509,19 @@ async function provision(progress) {
         if (r.code !== 0) {
             return fail(`playwright install chromium failed (exit ${r.code}). ${r.out.slice(-400)}`);
         }
+        // Smoke-test the EXACT gate the pipeline's post path runs at use time
+        // (twitter_post_plan.py preflight): the owned interpreter must import
+        // playwright. The reply step is the only Playwright importer, so a deps
+        // sync that left it unimportable was invisible until the first real post
+        // died with no_reply_json in production (Karol, 2026-06-22). Fail the
+        // install LOUDLY here instead.
+        const smoke = await sh(VENV_PYTHON, ["-c", "import playwright"], {
+            timeoutMs: 60000,
+        });
+        if (smoke.code !== 0) {
+            return fail(`runtime smoke test failed: ${VENV_PYTHON} cannot import playwright ` +
+                `(exit ${smoke.code}). ${smoke.out.slice(-400)}`);
+        }
     }
     setStep("chromium", "done");
     // --- Step 6: browser-harness CLI -----------------------------------------
@@ -607,6 +630,15 @@ async function provision(progress) {
     if (process.platform === "darwin") {
         const mb = await installMenubar(uv, uvEnv, VENV_PYTHON);
         setStep("menubar", mb.ok ? "done" : "error", mb.detail);
+        // Non-fatal step, so the only prior signal of a menu bar install failure was
+        // a local install-progress.json entry (invisible to us). Report it so "menu
+        // bar didn't start" becomes a real Sentry event with the failing detail.
+        if (!mb.ok) {
+            captureError(new Error(`menubar install failed: ${mb.detail}`), {
+                component: "menubar",
+                phase: "install",
+            });
+        }
     }
     else {
         setStep("menubar", "done", "skipped (macOS only)");

package/mcp/dist/telemetry.js

@@ -9,7 +9,7 @@
 import * as Sentry from "@sentry/node";
 import path from "node:path";
 import fs from "node:fs";
-import { repoDir, runPython } from "./repo.js";
+import { repoDir, runPython, setLineSink } from "./repo.js";
 import { VERSION } from "./version.js";
 // Sentry DSN is a client-side identifier (safe to embed, same posture as Fazm's
 // hardcoded Swift DSN). Overridable via env for dev. Empty -> Sentry disabled.
@@ -102,3 +102,129 @@ export async function sendHeartbeat(reason) {
         console.error("[social-autoposter-mcp] heartbeat failed:", err?.message || err);
     }
 }
+// ---- Raw subprocess log streaming ------------------------------------------
+// Tees the verbatim stdout/stderr of every pipeline subprocess (via the
+// repo.ts run() boundary) to the s4l backend, so we can troubleshoot and
+// rescue any user scenario without asking them to ship a log file. Lines are
+// buffered in memory and flushed in small batches under the same X-Installation
+// identity the heartbeat uses. Best-effort: this NEVER throws into the server,
+// never blocks the child's I/O, and drops on overflow rather than growing
+// unbounded. Disable with SAPS_LOG_STREAM=0.
+const LOG_STREAM_ENABLED = process.env.SAPS_LOG_STREAM !== "0";
+const LOG_MAX_LINE_LEN = 8192; // mirror the backend cap
+const LOG_MAX_BUFFER = 1000; // drop oldest beyond this (overflow protection)
+const LOG_FLUSH_BATCH = 100; // flush eagerly once we have this many lines
+const LOG_MAX_PER_POST = 200; // backend accepts 1-200 per request
+const LOG_FLUSH_MS = 3000; // otherwise flush on this cadence
+const logBuffer = [];
+let logDropped = 0; // count of lines dropped on overflow (surfaced periodically)
+let logFlushing = false;
+let logTimer;
+let cachedInstallHeader = null;
+let logStreamingStarted = false;
+async function installHeader() {
+    if (cachedInstallHeader)
+        return cachedInstallHeader;
+    try {
+        const idScript = path.join(repoDir(), "scripts", "identity.py");
+        if (!fs.existsSync(idScript))
+            return null;
+        const res = await runPython("scripts/identity.py", ["header"], { timeoutMs: 10_000 });
+        const header = (res.stdout || "").trim();
+        if (res.code === 0 && header) {
+            cachedInstallHeader = header;
+            return header;
+        }
+    }
+    catch {
+        /* best-effort */
+    }
+    return null;
+}
+// Buffer one raw line. Called from the repo.ts line sink, so it must be cheap
+// and total non-throwing.
+export function logLine(stream, line, context) {
+    if (!LOG_STREAM_ENABLED)
+        return;
+    try {
+        logBuffer.push({
+            ts: new Date().toISOString(),
+            stream,
+            line: line.length > LOG_MAX_LINE_LEN ? line.slice(0, LOG_MAX_LINE_LEN) : line,
+            context: context || "",
+        });
+        if (logBuffer.length > LOG_MAX_BUFFER) {
+            // Drop oldest to bound memory; the newest lines are the most useful.
+            logDropped += logBuffer.length - LOG_MAX_BUFFER;
+            logBuffer.splice(0, logBuffer.length - LOG_MAX_BUFFER);
+        }
+        if (logBuffer.length >= LOG_FLUSH_BATCH)
+            void flushLogs();
+    }
+    catch {
+        /* never throw into the run() boundary */
+    }
+}
+export async function flushLogs() {
+    if (!LOG_STREAM_ENABLED)
+        return;
+    if (logFlushing || logBuffer.length === 0)
+        return;
+    logFlushing = true;
+    try {
+        const header = await installHeader();
+        if (!header)
+            return; // runtime not unpacked yet; keep buffering
+        const base = (process.env.AUTOPOSTER_API_BASE || "https://s4l.ai").replace(/\/+$/, "");
+        // Drain in <=200-line POSTs until the buffer empties (or a POST fails).
+        while (logBuffer.length > 0) {
+            const batch = logBuffer.splice(0, LOG_MAX_PER_POST);
+            const lines = batch.map((b) => ({
+                ts: b.ts,
+                stream: b.stream,
+                line: b.line,
+                context: b.context || undefined,
+            }));
+            try {
+                const resp = await fetch(`${base}/api/v1/installations/logs`, {
+                    method: "POST",
+                    headers: { "X-Installation": header, "content-type": "application/json" },
+                    body: JSON.stringify({ lines }),
+                    signal: AbortSignal.timeout(15_000),
+                });
+                if (!resp.ok) {
+                    // Drop this batch (don't re-buffer): a persistent 4xx/5xx would grow
+                    // the buffer unbounded. The raw stream is best-effort.
+                    console.error(`[social-autoposter-mcp] log flush http ${resp.status}`);
+                    break;
+                }
+            }
+            catch (err) {
+                // Network blip: drop this batch, stop draining, try again next tick.
+                console.error("[social-autoposter-mcp] log flush failed:", err?.message || err);
+                break;
+            }
+        }
+        if (logDropped > 0) {
+            console.error(`[social-autoposter-mcp] log stream dropped ${logDropped} line(s) on overflow`);
+            logDropped = 0;
+        }
+    }
+    finally {
+        logFlushing = false;
+    }
+}
+// Register the repo.ts line sink and start the periodic flush. Idempotent.
+export function startLogStreaming() {
+    if (!LOG_STREAM_ENABLED || logStreamingStarted)
+        return;
+    logStreamingStarted = true;
+    try {
+        setLineSink((line, stream, context) => logLine(stream, line, context));
+        logTimer = setInterval(() => void flushLogs(), LOG_FLUSH_MS);
+        logTimer.unref();
+    }
+    catch (err) {
+        console.error("[social-autoposter-mcp] log streaming start failed:", err?.message || err);
+    }
+}

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.82",
-  "installedAt": "2026-06-22T21:04:08.350Z"
+  "version": "1.6.84",
+  "installedAt": "2026-06-23T02:53:37.786Z"
 }

package/mcp/manifest.json

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

@@ -24,9 +24,58 @@ import tempfile
 import threading
 import time
 
-import rumps
-
-import s4l_state as st
+# --- Sentry bootstrap --------------------------------------------------------
+# The menu bar runs as a standalone KeepAlive LaunchAgent off the owned venv,
+# a separate process from the MCP server, so it was a Sentry blind spot: a crash
+# (most often rumps missing/broken in the venv -> "menu bar didn't start") only
+# ever landed in the local menubar.err.log. Wire it in BEFORE importing rumps so
+# even an import-time failure of the menu bar's heaviest dependency is reported.
+# sentry_init lives in the pipeline's scripts/ dir (SAPS_REPO_DIR is exported by
+# the launchd plist) and sentry-sdk is in the owned venv (requirements.txt). All
+# best-effort: a missing repo path or SDK degrades to a silent no-op.
+_sentry = None
+try:
+    _repo = os.environ.get("SAPS_REPO_DIR")
+    if _repo:
+        _scripts = os.path.join(_repo, "scripts")
+        if _scripts not in sys.path:
+            sys.path.insert(0, _scripts)
+    import sentry_init as _sentry  # noqa: E402
+
+    _sentry.init()
+except Exception:
+    _sentry = None
+
+
+def _capture(err, **tags):
+    """Report a handled menu-bar error to Sentry (component=menubar) without ever
+    raising into the caller. No-op if the Sentry bootstrap above failed."""
+    try:
+        if _sentry is not None:
+            tags.setdefault("component", "menubar")
+            _sentry.capture_exception(err, tags=tags)
+    except Exception:
+        pass
+
+
+def _flush():
+    try:
+        if _sentry is not None:
+            _sentry.flush()
+    except Exception:
+        pass
+
+
+try:
+    import rumps  # noqa: E402
+except Exception as _import_err:
+    # rumps missing/broken in the owned venv is THE "menu bar didn't start" case.
+    # Report it explicitly, flush, then re-raise so launchd records the crash too.
+    _capture(_import_err, phase="import_rumps")
+    _flush()
+    raise
+
+import s4l_state as st  # noqa: E402
 
 CLAUDE_APP = "Claude"
 POLL_SECONDS = 5
@@ -432,6 +481,7 @@ class S4LMenuBar(rumps.App):
             self._review_active = False
             sys.stderr.write(f"[s4l-menubar] review cards failed: {e}\n")
             sys.stderr.flush()
+            _capture(e, phase="review_cards")
 
     def _on_review_done(self, batch, decisions):
         # Runs on the main thread (from the card controller). Translate decisions
@@ -598,4 +648,11 @@ class S4LMenuBar(rumps.App):
 
 
 if __name__ == "__main__":
-    S4LMenuBar().run()
+    try:
+        S4LMenuBar().run()
+    except Exception as _run_err:
+        # The run loop dying is the other "menu bar didn't start / vanished" case.
+        # Report + flush before the KeepAlive relaunch so it isn't lost on teardown.
+        _capture(_run_err, phase="run")
+        _flush()
+        raise

package/mcp/package.json

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