social-autoposter 1.6.72 → 1.6.74

package/mcp/dist/index.js

@@ -30,6 +30,15 @@ import http from "node:http";
 // (vite-plugin-singlefile) into dist/panel.html alongside this compiled file.
 const DIST_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PANEL_URI = "ui://social-autoposter/panel.html";
+// Stable id for the accumulating draft review queue. submit_drafts appends each
+// run's drafts here (dedup by tweet URL) so the menu-bar cards PILE UP across a
+// continuous autopilot instead of each run overwriting the last; post_drafts posts
+// the approved subset and marks them posted (filtered out of the cards thereafter).
+const REVIEW_QUEUE_ID = "review-queue";
+// The Desktop scheduled task onboarding creates for the autopilot. Its presence on
+// disk is the single "autopilot is set up" signal the dashboard + menu bar share
+// (the legacy launchd autopilot is retired).
+const AUTOPILOT_TASK_ID = "social-autoposter-autopilot";
 const TWITTER_AUTOPILOT_LABEL = "com.m13v.social-twitter-cycle";
 const TWITTER_AUTOPILOT_PLIST = path.join(os.homedir(), "Library", "LaunchAgents", `${TWITTER_AUTOPILOT_LABEL}.plist`);
 // Daily self-updater. Enabled alongside autopilot so a hands-free (headless)
@@ -152,8 +161,9 @@ const server = new McpServer({
         "ONBOARDING IS A TERMINAL GOAL. When the user asks to set up, install, configure, or onboard " +
         "social-autoposter, keep taking the next safe action until the owned runtime is ready, a " +
         "project is fully configured with seeded search topics, X is connected with its real handle, " +
-        "and the draft path (`scan_candidates` -> draft -> `submit_drafts`) has verified the pipeline " +
-        "without posting. Do not ask whether to inspect " +
+        "the draft path (`scan_candidates` -> draft -> `submit_drafts`) has verified the pipeline " +
+        "without posting, AND the recurring autopilot scheduled task has been created and run once " +
+        "(see SCHEDULE THE AUTOPILOT below). Do not ask whether to inspect " +
         "status, install or repair owned dependencies, choose an auto-detected browser profile, connect " +
         "X, scan the profile, research the product website, save conservative inferred fields, seed " +
         "topics, retry a recoverable failure, or run draft-only verification. Do those things. The " +
@@ -161,12 +171,24 @@ const server = new McpServer({
         "twitter.com session cookies into the managed browser: warn that macOS keychain prompts may " +
         "appear, then proceed without a separate yes/no turn. Ask at most one bundled question, only " +
         "when no product can be identified from config, context, the X profile, or public research, " +
-        "or pause for an unavoidable interactive login or OS prompt. Never post drafts or enable " +
-        "autopilot during setup unless the user explicitly requested that. When setup reaches done — " +
-        "runtime ready, a project configured with seeded topics, X connected, and the draft path " +
-        "(scan_candidates -> draft -> submit_drafts) verified — call the `dashboard` tool so the user " +
+        "or pause for an unavoidable interactive login or OS prompt. Never auto-POST during setup, but " +
+        "DO schedule the draft-only autopilot as the final step (it only queues drafts for approval, it " +
+        "never posts on its own). When setup reaches done (" +
+        "runtime ready, a project configured with seeded topics, X connected, the draft path verified, " +
+        "and the autopilot scheduled task created and run once), call the `dashboard` tool so the user " +
         "sees the finished setup rendered, then give " +
         "the completion summary.\n\n" +
+        "SCHEDULE THE AUTOPILOT (final onboarding step). Once the draft path is verified, start the " +
+        "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, 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). Then run ONE cycle yourself now (scan_candidates -> " +
+        "draft -> submit_drafts) to seed the cards and pre-approve the tools, so unattended fires do not " +
+        "stall on a 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 " +
         "something worth talking about in this session (a new feature, a launch, a long-awaited fix, a " +
         "milestone), don't wait to be asked: offer to tell the world by running a draft cycle " +
@@ -469,8 +491,11 @@ async function produceDrafts(project, onProgress) {
 function renderDraftsTable(plan) {
     const candidates = plan.candidates || [];
     return candidates
-        .map((c, i) => {
-        const n = i + 1;
+        // Number by FULL-array index (matches post_drafts + the menu bar), then drop
+        // already-posted entries so the cards only show what's still pending.
+        .map((c, i) => ({ c, n: i + 1 }))
+        .filter((e) => e.c.posted !== true)
+        .map(({ c, n }) => {
         const author = c.thread_author ? `@${c.thread_author}` : "(unknown thread)";
         const style = c.engagement_style ?? "?";
         const reply = c.reply_text ?? "(empty)";
@@ -922,7 +947,7 @@ tool("project_config", {
                         (x.connected ? "" : " X is not connected yet either — detect_x_sources, warn about keychain prompts, then run connect_x with confirm:true without a separate permission turn.")
                     : projects.every((p) => p.ready)
                         ? (x.connected
-                            ? "All configured projects are ready and X is connected. Run scan_candidates, draft a reply or two, and submit_drafts now to verify end to end without posting. After it verifies, call the `dashboard` tool so the user sees the finished setup."
+                            ? "All configured projects are ready and X is connected. Run scan_candidates, draft a reply or two, and submit_drafts now to verify end to end without posting. Then SCHEDULE THE AUTOPILOT: call create_scheduled_task (taskId 'social-autoposter-autopilot', cron '* * * * *', prompt = scan_candidates -> draft -> submit_drafts, draft-only) and run one cycle now. Then call the `dashboard` tool so the user sees the finished setup."
                             : "All configured projects are ready, but X is NOT connected — posting needs a logged-in " +
                                 "x.com session. Detect sources and run project_config action:'connect_x', confirm:true; do not ask whether to proceed.")
                         : "Some projects are missing required fields (see each project's missing_required). Derive them from config, context, profile_scan, and website research, then call project_config again. Ask only if a required field is genuinely unknowable." +
@@ -1034,8 +1059,9 @@ tool("project_config", {
             note: (result.ready
                 ? `Project '${result.project}' is fully configured.${seedNote} Next: if X is not connected, ` +
                     `detect sources, warn about keychain prompts, and call project_config with ` +
-                    `action:'connect_x', confirm:true immediately. Once X is connected, run scan_candidates -> submit_drafts to` +
-                    `verify without posting. Do not enable autopilot unless explicitly requested.`
+                    `action:'connect_x', confirm:true immediately. Once X is connected, run scan_candidates -> submit_drafts ` +
+                    `to verify without posting, then schedule the draft-only autopilot (create_scheduled_task, cron '* * * * *', ` +
+                    `prompt = scan_candidates -> draft -> submit_drafts) and run one cycle now.`
                 : `Saved what you provided for '${result.project}'. Still need: ${result.missing_required.join(", ")}. ` +
                     `First derive those fields from existing context, profile_scan, and website research, then ` +
                     `call project_config again with name='${result.project}'. Ask only if a required field is genuinely unknowable.`) +
@@ -1332,18 +1358,28 @@ function runtimeSnapshot() {
 // and re-reads status. The tool itself returns the first-paint snapshot so the
 // view has data the instant it loads.
 // Is either launchd job (cycle / daily updater) currently loaded?
+// "Autopilot" is now the Claude Desktop scheduled task `social-autoposter-autopilot`
+// (created during onboarding via create_scheduled_task), NOT the legacy launchd job.
+// We can't read the host's enabled/paused flag, but the task's presence on disk is the
+// single signal the dashboard AND the menu bar key off of, so they stay aligned.
 async function autopilotLoaded() {
+    let autopilot_on = false;
+    try {
+        const cfg = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
+        autopilot_on = fs.existsSync(path.join(cfg, "scheduled-tasks", AUTOPILOT_TASK_ID, "SKILL.md"));
+    }
+    catch {
+        /* leave false */
+    }
+    let auto_update_on = false;
     try {
         const res = await run("launchctl", ["list"], { timeoutMs: 10_000 });
-        const lines = res.stdout.split("\n");
-        return {
-            autopilot_on: lines.some((l) => l.includes(TWITTER_AUTOPILOT_LABEL)),
-            auto_update_on: lines.some((l) => l.includes(UPDATER_LABEL)),
-        };
+        auto_update_on = res.stdout.split("\n").some((l) => l.includes(UPDATER_LABEL));
     }
     catch {
-        return { autopilot_on: false, auto_update_on: false };
+        /* leave false */
     }
+    return { autopilot_on, auto_update_on };
 }
 // Assemble everything the panel needs in one shot (projects + X + autopilot +
 // version). Resilient: any probe that throws degrades to a safe default rather
@@ -1719,11 +1755,10 @@ tool("submit_drafts", {
     const project = (candidates.map((c) => c.matched_project).find((p) => !!p) ||
         firstSc?.matched_project ||
         "default");
-    const plan = { candidates };
-    writePlan(args.batch_id, plan);
-    // Bake link targets into the plan (sub-second at TWITTER_PAGE_GEN_RATE=0), the
-    // same prep step DRAFT_ONLY does before handing off. Best-effort: posting
-    // falls back to the plain project URL per-candidate if this is skipped.
+    // Stage the new drafts under the scan batch id and bake link targets into them
+    // (sub-second at TWITTER_PAGE_GEN_RATE=0). Best-effort: posting falls back to the
+    // plain project URL per-candidate if gen is skipped.
+    writePlan(args.batch_id, { candidates });
     try {
         await runPython("scripts/twitter_gen_links.py", ["--plan", planPath(args.batch_id)], {
             timeoutMs: 120_000,
@@ -1733,25 +1768,45 @@ tool("submit_drafts", {
     catch {
         /* best effort — plan still posts with a plain-URL fallback */
     }
-    const finalPlan = readPlan(args.batch_id) ?? plan;
-    const count = (finalPlan.candidates || []).length;
+    const staged = readPlan(args.batch_id)?.candidates ?? candidates;
+    // Accumulate into ONE persistent review queue so a continuous autopilot's drafts
+    // PILE UP in the menu-bar cards instead of each run overwriting the last. New
+    // drafts are appended; a thread already in the queue (by URL) is skipped (one
+    // draft per thread). Posted entries are KEPT in place so the 1-based card
+    // numbering stays stable across runs — the menu bar, the chat table, and
+    // post_drafts all index the full array and filter on the `posted` flag.
+    const queue = [
+        ...(readPlan(REVIEW_QUEUE_ID)?.candidates ?? []),
+    ];
+    const seen = new Set(queue.map((c) => c.candidate_url).filter((u) => !!u));
+    let added = 0;
+    for (const nc of staged) {
+        if (nc.candidate_url && seen.has(nc.candidate_url))
+            continue;
+        queue.push(nc);
+        if (nc.candidate_url)
+            seen.add(nc.candidate_url);
+        added++;
+    }
+    writePlan(REVIEW_QUEUE_ID, { candidates: queue });
+    const pending = queue.filter((c) => c.posted !== true);
     // Drafts queued = the pipeline verified end-to-end without posting. This is the
     // onboarding "draft_verified" terminal goal (formerly completed by draft_cycle).
-    if (count > 0)
-        completeOnboardingMilestone("draft_verified", { outcome: "review_batch", draft_count: count });
-    // Surface to the menu-bar review cards (same review plan draft_cycle used).
+    if (added > 0)
+        completeOnboardingMilestone("draft_verified", { outcome: "review_batch", draft_count: added });
+    // Point the menu-bar review cards at the accumulated queue.
     writeReviewRequest({
-        batch_id: args.batch_id,
+        batch_id: REVIEW_QUEUE_ID,
         project,
-        count,
-        plan_path: planPath(args.batch_id),
+        count: pending.length,
+        plan_path: planPath(REVIEW_QUEUE_ID),
         created_at: new Date().toISOString(),
     });
-    return textContent(`${count} draft(s) queued for review (batch ${args.batch_id}). They're now in the menu-bar ` +
-        `approval cards and the table below; nothing posts until approved.\n\n` +
-        renderDraftsTable(finalPlan) +
-        `\n\nTo post the approved ones: the user approves in the menu bar, or call post_drafts with the ` +
-        `numbers to post.`);
+    return textContent(`Queued ${added} new draft(s); ${pending.length} now awaiting approval in the menu-bar cards ` +
+        `(review queue "${REVIEW_QUEUE_ID}"). Nothing posts until approved.\n\n` +
+        renderDraftsTable({ candidates: queue }) +
+        `\n\nTo post: the user approves in the menu bar, or call post_drafts with batch_id ` +
+        `"${REVIEW_QUEUE_ID}" and the numbers to post.`);
 });
 appTool("dashboard", {
     title: "Social Autoposter dashboard",

package/mcp/dist/version.js

@@ -2,10 +2,12 @@
 //
 // The "real" version is the top-level `social-autoposter` npm package version
 // (e.g. 1.6.x) — that is what actually bundles this MCP's prebuilt dist/. The
-// MCP's own package.json (0.0.1) and manifest (0.0.1) are decoupled artifacts
-// that nobody bumps, so they are NOT a reliable signal. This module resolves the
-// true version from the most authoritative source available at runtime, and can
-// check npm for a newer published release so we can deliver updates on demand.
+// MCP's own package.json and manifest are stamped to the same version at release
+// time (scripts/release-mcpb.sh step 3b), but historically they were frozen at
+// 0.0.1, so this module still resolves the true version from the most
+// authoritative source available at runtime (and tolerates a stale co-located
+// package.json on an old bundle). It can also check npm for a newer published
+// release so we can deliver updates on demand.
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -26,7 +28,8 @@ function readJsonVersion(p) {
 //      from the npm package version at every init/update. Authoritative on a
 //      real user install, where the top-level package.json is NOT copied.
 //   2. <repo>/package.json — git checkout / dev machine: the meaningful 1.6.x.
-//   3. mcp/package.json    — co-located last resort (currently 0.0.1).
+//   3. mcp/package.json    — co-located last resort (release-stamped to match,
+//      but may be stale on an older bundle).
 export function resolveVersion() {
     return (readJsonVersion(path.join(__dirname, "version.json")) ||
         readJsonVersion(path.join(repoDir(), "package.json")) ||

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.71",
-  "installedAt": "2026-06-20T16:29:20.789Z"
+  "version": "1.6.73",
+  "installedAt": "2026-06-20T18:16:22.534Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "Social Autoposter",
-  "version": "0.0.1",
+  "version": "1.6.73",
   "description": "Draft, review, approve, and autopilot X/Twitter posts. Thin desktop client over the social-autoposter pipeline.",
   "long_description": "A guided assistant that drafts, reviews, and autopilots X/Twitter posts.\nTo get started:\n1. Fully quit and restart Claude (quit and reopen, not just close the window).\n2. Choose **Set up social-autoposter** from the prompt menu or type **Set me up on social-autoposter end to end**. The agent installs the owned runtime, connects X, discovers and configures your product, and verifies with a draft-only cycle.",
   "author": {
@@ -15,7 +15,9 @@
     "entry_point": "dist/index.js",
     "mcp_config": {
       "command": "node",
-      "args": ["${__dirname}/dist/index.js"],
+      "args": [
+        "${__dirname}/dist/index.js"
+      ],
       "env": {
         "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
       }
@@ -43,7 +45,13 @@
       "description": "Render the visual dashboard (MCP Apps UI): project setup, X connection, autopilot state, and 7-day stats, with buttons to run a draft cycle, connect X, and refresh. Also rendered automatically after state-changing actions."
     }
   ],
-  "keywords": ["twitter", "x", "social", "autoposter", "marketing"],
+  "keywords": [
+    "twitter",
+    "x",
+    "social",
+    "autoposter",
+    "marketing"
+  ],
   "license": "UNLICENSED",
   "repository": {
     "type": "git",

package/mcp/menubar/s4l_menubar.py

@@ -191,12 +191,8 @@ class S4LMenuBar(rumps.App):
         except Exception:
             pass
 
-    def _toggle_ap(self, sender):
-        desired = not bool(sender.state)
-        if st.set_autopilot(desired):
-            sender.state = 1 if desired else 0
-        else:
-            self._notify("S4L", "Open Claude Desktop to change autopilot.")
+    # _toggle_ap removed: autopilot is the Claude Desktop scheduled task now, managed
+    # in the Scheduled tab. The menu bar mirrors the dashboard (no launchd toggle).
 
     # ---- activity spinner -------------------------------------------------
     # The server writes activity.json while a tool runs (scanning/drafting/
@@ -469,9 +465,6 @@ class S4LMenuBar(rumps.App):
             out.append(self._label("7d stats — open dashboard"))
 
         out.append(rumps.separator)
-        ap = rumps.MenuItem("Autopilot", callback=self._toggle_ap)
-        ap.state = 1 if snap.get("autopilot_on") else 0
-        out.append(ap)
         out.append(
             rumps.MenuItem("Run draft cycle in Claude", callback=self._draft)
         )

package/mcp/menubar/s4l_state.py

@@ -103,7 +103,11 @@ def _launchctl_list() -> str:
 
 
 def autopilot_loaded() -> bool:
-    return AUTOPILOT_LABEL in _launchctl_list()
+    # Autopilot is now the Claude Desktop scheduled task, not the legacy launchd job.
+    cfg = os.environ.get("CLAUDE_CONFIG_DIR") or os.path.join(str(Path.home()), ".claude")
+    return os.path.exists(
+        os.path.join(cfg, "scheduled-tasks", "social-autoposter-autopilot", "SKILL.md")
+    )
 
 
 # ---- loopback panel server (live, when Claude Desktop is running) ----------
@@ -207,35 +211,9 @@ def stats_7d():
     }
 
 
-def set_autopilot(enable: bool) -> bool:
-    """Toggle background posting. Prefer the loopback tool (it creates the plist
-    correctly on first enable); fall back to launchctl against the existing
-    plist when Claude Desktop is closed. Returns False if it couldn't act."""
-    res = loopback_tool("autopilot", {"action": "enable" if enable else "disable"})
-    if res is not None:
-        return True
-    plist = str(
-        Path.home() / "Library" / "LaunchAgents" / (AUTOPILOT_LABEL + ".plist")
-    )
-    uid = os.getuid()
-    try:
-        if enable:
-            if not os.path.exists(plist):
-                return False  # first enable needs the server to write the plist
-            subprocess.run(
-                ["launchctl", "bootstrap", f"gui/{uid}", plist],
-                capture_output=True,
-                timeout=15,
-            )
-        else:
-            subprocess.run(
-                ["launchctl", "bootout", f"gui/{uid}/{AUTOPILOT_LABEL}"],
-                capture_output=True,
-                timeout=15,
-            )
-        return True
-    except Exception:
-        return False
+# set_autopilot() (the launchd toggle) was removed: the autopilot is now the Claude
+# Desktop scheduled task `social-autoposter-autopilot`, managed in the Scheduled tab,
+# so the menu bar no longer toggles a launchd job (it mirrors the dashboard instead).
 
 
 def panel_url():

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "0.0.1",
+  "version": "1.6.73",
   "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.",
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-autoposter",
-  "version": "1.6.72",
+  "version": "1.6.74",
   "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/release-mcpb.sh

@@ -75,6 +75,31 @@ fs.writeFileSync(p, JSON.stringify({version:'$VERSION',installedAt:new Date().to
 console.log('  '+fs.readFileSync(p,'utf8').trim());
 "
 
+# ---- 3b. Stamp manifest.json + mcp/package.json + lockfile version ----------
+# Claude Desktop's extension "Details" panel reads version from manifest.json,
+# so it must track the release version too (not the frozen 0.0.1 placeholder).
+# mcp/package.json and its lockfile are stamped in lockstep so the three stay
+# consistent (npm errors if package.json and package-lock.json disagree).
+say "Stamping mcp/manifest.json + mcp/package.json + mcp/package-lock.json -> $VERSION"
+node -e "
+const fs=require('fs');
+const V='$VERSION';
+for (const p of ['$MCP_DIR/manifest.json','$MCP_DIR/package.json']) {
+  const j=JSON.parse(fs.readFileSync(p,'utf8'));
+  j.version=V;
+  fs.writeFileSync(p, JSON.stringify(j,null,2)+'\n');
+  console.log('  '+p.replace('$MCP_DIR/','mcp/')+' -> '+j.version);
+}
+const lp='$MCP_DIR/package-lock.json';
+if (fs.existsSync(lp)) {
+  const l=JSON.parse(fs.readFileSync(lp,'utf8'));
+  l.version=V;
+  if (l.packages && l.packages['']) l.packages[''].version=V;
+  fs.writeFileSync(lp, JSON.stringify(l,null,2)+'\n');
+  console.log('  mcp/package-lock.json -> '+l.version);
+}
+"
+
 # ---- 4. Pack the .mcpb ------------------------------------------------------
 say "Packing $BUNDLE"
 rm -f "$BUNDLE"
@@ -99,6 +124,10 @@ BUNDLE_VER=$(unzip -p "$BUNDLE" dist/version.json 2>/dev/null | node -p "JSON.pa
 [[ "$BUNDLE_VER" == "$VERSION" ]] || die "bundle version.json=$BUNDLE_VER != $VERSION"
 echo "  version.json: $BUNDLE_VER ok"
 
+MANIFEST_VER=$(unzip -p "$BUNDLE" manifest.json 2>/dev/null | node -p "JSON.parse(require('fs').readFileSync(0,'utf8')).version" 2>/dev/null || echo "?")
+[[ "$MANIFEST_VER" == "$VERSION" ]] || die "bundle manifest.json=$MANIFEST_VER != $VERSION (Desktop Details panel would show the wrong version)"
+echo "  manifest.json: $MANIFEST_VER ok"
+
 for f in "dist/index.js" "dist/runtime.js" "manifest.json"; do
   # grep -c reads all input (no SIGPIPE); anchor on the time column + 3-space
   # gutter so node_modules/.../dist/index.js does not false-match the top-level.