social-autoposter 1.6.74 → 1.6.75

package/mcp/dist/index.js

@@ -637,8 +637,10 @@ const WEBSITE_RESEARCH_INSTRUCTIONS = "PRODUCT RESEARCH (do this before saving t
     "register, vibe) while keeping every product CLAIM factual to the site. Don't invent " +
     "features, metrics, or guarantees the site doesn't state.\n" +
     "5. Save the best conservative factual draft without adding a confirmation round-trip. Call " +
-    "project_config with name + the product fields (plus voice/search_topics from the profile scan). If the " +
-    "site is thin or unreachable, use only supported facts and leave optional detail conservative; " +
+    "project_config with name + the product fields (plus voice/search_topics from the profile scan), AND " +
+    "expand those topics into a `search_queries` array of ~30 concrete X advanced-search strings in the " +
+    "SAME call — YOU are the model, so do the expansion in-session; it seeds directly with no `claude -p`. " +
+    "If the site is thin or unreachable, use only supported facts and leave optional detail conservative; " +
     "ask the user only if a required field is genuinely unknowable.";
 // ---- project_config: per-project config (the "brain": project, website, voice) -----
 // Run this FIRST. The action tools refuse until at least one project is ready.
@@ -730,6 +732,14 @@ tool("project_config", {
             .union([z.array(z.string()), z.string()])
             .optional()
             .describe("Topics/keywords to monitor on X (comma-separated or array)"),
+        search_queries: z
+            .array(z.string())
+            .optional()
+            .describe("Cold-start X search-query bank YOU expand from search_topics, in this same call. " +
+            "Fan each topic into a few concrete X advanced-search strings (aim ~30 total, e.g. " +
+            "'mac menu bar app -filter:replies', 'screen recording privacy lang:en') so the cycle " +
+            "fans out instead of running one crude topic-as-query. Seeded directly with NO `claude " +
+            "-p` — you are the model doing the expansion, so setup never needs the claude CLI."),
         get_started_link: z
             .string()
             .optional()
@@ -1001,13 +1011,28 @@ tool("project_config", {
             // search queries (project_search_queries) so the deterministic Phase 1
             // bank (qualified_query_bank.py) has something to run on day one.
             // Without this, a freshly-configured project's bank is empty and the
-            // cycle falls back to ONE crude topic-as-query. Best-effort: a failure
-            // here never fails setup; the topic-as-query fallback still works, just
-            // narrower. Supply-test is auto (only if the harness is up), so this
-            // stays fast when X isn't connected yet. (2026-06-04)
-            if (seed.code === 0) {
+            // cycle falls back to ONE crude topic-as-query.
+            //
+            // CLAUDE-FREE: the in-session agent (you) expands topics -> queries and
+            // passes them as `search_queries` in THIS call. We seed them directly via
+            // --queries-json, so setup never shells out to `claude -p` (which isn't
+            // installed in the Desktop / .mcpb lane and was the FileNotFoundError
+            // users hit). If the agent didn't supply queries, we skip expansion
+            // entirely — the topic-as-query fallback still runs, just narrower — and
+            // nudge the agent to re-run with search_queries. (2026-06-19)
+            const agentQueries = Array.isArray(args.search_queries)
+                ? args.search_queries.map((q) => String(q).trim()).filter(Boolean)
+                : [];
+            if (seed.code === 0 && agentQueries.length) {
                 try {
-                    const qseed = await runPython("scripts/seed_search_queries.py", ["--project", result.project, "--supply-test", "auto", "--emit-json"], { timeoutMs: 600_000 });
+                    const qfile = path.join(os.tmpdir(), `saps-queries-${result.project}-${Date.now()}.json`);
+                    fs.writeFileSync(qfile, JSON.stringify({ queries: agentQueries.map((q) => ({ query: q, topic: "" })) }));
+                    const qseed = await runPython("scripts/seed_search_queries.py", ["--project", result.project, "--queries-json", qfile,
+                        "--supply-test", "auto", "--emit-json"], { timeoutMs: 600_000 });
+                    try {
+                        fs.unlinkSync(qfile);
+                    }
+                    catch { /* best-effort cleanup */ }
                     const qm = /seeded=(\d+)\s+inserted=(\d+)\s+updated=(\d+)/.exec(qseed.stdout);
                     const qjson = qseed.stdout.split("===QUERIES_JSON===")[1];
                     if (qjson) {
@@ -1020,17 +1045,20 @@ tool("project_config", {
                     }
                     if (qseed.code === 0 && qm) {
                         const n = searchQueries.length || Number(qm[1]);
-                        seedNote += ` Expanded them into ${n} search quer${n === 1 ? "y" : "ies"} so the cycle can fan out instead of running a single query.`;
+                        seedNote += ` Seeded ${n} search quer${n === 1 ? "y" : "ies"} so the cycle can fan out instead of running a single query.`;
                     }
                     else if (qseed.code !== 0) {
                         const qtail = (qseed.stderr || qseed.stdout).trim().split("\n").slice(-1)[0] || "unknown error";
-                        seedNote += ` (Search queries not expanded yet — ${qtail}. The cycle still runs off the seeded topics.)`;
+                        seedNote += ` (Search queries not seeded yet — ${qtail}. The cycle still runs off the seeded topics.)`;
                     }
                 }
                 catch (e) {
-                    seedNote += ` (Search-query expansion skipped — ${e.message}.)`;
+                    seedNote += ` (Search-query seeding skipped — ${e.message}.)`;
                 }
             }
+            else if (seed.code === 0) {
+                seedNote += ` (No search_queries supplied, so the cycle will run off the seeded topics one at a time. To fan out, re-call project_config with a search_queries array of ~30 X search strings you expand from these topics — it seeds them directly, no claude CLI.)`;
+            }
         }
         // Surface any advanced (escape-hatch) field edits in the note so the
         // agent can confirm exactly what changed to the user.

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.73",
-  "installedAt": "2026-06-20T18:16:22.534Z"
+  "version": "1.6.75",
+  "installedAt": "2026-06-20T23:27:03.057Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "Social Autoposter",
-  "version": "1.6.73",
+  "version": "1.6.75",
   "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": {

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/social-autoposter-mcp",
-  "version": "1.6.73",
+  "version": "1.6.75",
   "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.74",
+  "version": "1.6.75",
   "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/seed_search_queries.py

@@ -132,6 +132,35 @@ def _fetch_active_queries(project: str) -> list[dict]:
     return out
 
 
+def _load_provided_queries(path: str) -> list[tuple[str, str]]:
+    """Read AGENT-SUPPLIED queries from a JSON file: returns (query, topic) pairs.
+
+    Accepts either {"queries": [...]} or a bare top-level list. Each item may be
+    a string (topic left blank) or an object {"query": ..., "topic": ...}.
+    This is the claude-free seed path: the in-session agent already expanded the
+    topics into queries, so there is nothing to draft."""
+    with open(path, "r", encoding="utf-8") as fh:
+        raw = json.load(fh)
+    items = raw.get("queries") if isinstance(raw, dict) else raw
+    out: list[tuple[str, str]] = []
+    seen: set[str] = set()
+    for it in (items or []):
+        if isinstance(it, str):
+            q, t = it.strip(), ""
+        elif isinstance(it, dict):
+            q, t = (it.get("query") or "").strip(), (it.get("topic") or "").strip()
+        else:
+            continue
+        if not q:
+            continue
+        core = normalize_query(q)
+        if core in seen:
+            continue
+        seen.add(core)
+        out.append((q, t))
+    return out
+
+
 def _find_project(cfg: dict, name: str) -> dict | None:
     for p in cfg.get("projects", []):
         if (p.get("name") or "").strip().lower() == name.strip().lower():
@@ -181,6 +210,12 @@ def main() -> int:
                          "bank as JSON on a sentinel line (===QUERIES_JSON===) so a "
                          "caller (e.g. the MCP setup tool) can hand the queries back "
                          "to the user.")
+    ap.add_argument("--queries-json",
+                    help="Path to a JSON file of AGENT-SUPPLIED queries to seed "
+                         "directly, bypassing the `claude -p` drafting loop entirely. "
+                         "Shape: {\"queries\":[{\"query\":\"...\",\"topic\":\"...\"}]} "
+                         "or a bare list of strings. Use this from the in-session MCP "
+                         "setup path so the seed step never depends on the claude CLI.")
     args = ap.parse_args()
 
     cfg = load_config()
@@ -192,53 +227,84 @@ def main() -> int:
     # canonical name as stored
     project = (project_entry.get("name") or args.project).strip()
 
-    topics = _load_active_topics(project)
-    if not topics:
-        print(f"seed_search_queries: no active topics for {project!r} — seed "
-              f"topics first (scripts/seed_search_topics.py).", file=sys.stderr)
-        return 3
-
     target = max(1, args.target)
 
-    # Idempotency: aim for `target` TOTAL active queries, not `target` NEW per
-    # run. A project that already has >= target active seed queries needs no
-    # drafting — re-running reseed just re-emits the existing bank instead of
-    # ballooning it. Otherwise we only draft the shortfall. (2026-06-04)
-    active_now = len(_fetch_active_queries(project))
-    need = max(0, target - active_now)
-    per_topic = math.ceil(need / len(topics)) if need else 0
-    per_topic = max(MIN_PER_TOPIC, min(MAX_PER_TOPIC, per_topic)) if need else 0
-
-    # Dedup against (a) every query EVER attempted for this project and (b) seed
-    # queries already persisted. Accumulates as we go so topics don't overlap.
-    avoid_cores = load_existing_query_cores(project) | _load_existing_seed_cores(project)
-
-    print(f"seed_search_queries: project={project!r} topics={len(topics)} "
-          f"target={target} active_now={active_now} need={need} "
-          f"per_topic={per_topic} existing_cores={len(avoid_cores)}",
-          file=sys.stderr)
-
-    # --- Draft queries topic by topic ------------------------------------
-    drafted: list[tuple[str, str]] = []  # (query, topic)
-    for topic in topics:
-        if need <= 0 or len({normalize_query(q) for q, _ in drafted}) >= need:
-            break
-        prompt = build_query_prompt(
-            project_entry, topic, per_topic, avoid_queries=avoid_cores
-        )
-        try:
-            out = call_claude(prompt, timeout_sec=DRAFT_TIMEOUT_SEC)
-        except SystemExit as e:
-            print(f"[seed_search_queries] draft failed for topic {topic!r}: {e}",
-                  file=sys.stderr)
-            continue
-        qs = extract_queries(out, per_topic)
-        new_qs, dupes = dedup_queries(qs, avoid_cores)
-        for q in new_qs:
-            avoid_cores.add(normalize_query(q))
-            drafted.append((q, topic))
-        print(f"  topic={topic!r}: drafted={len(qs)} new={len(new_qs)} "
-              f"dupes={len(dupes)}", file=sys.stderr)
+    # ---- Agent-supplied path (claude-free) ------------------------------
+    # When the caller (the in-session MCP setup tool) hands us queries the agent
+    # already expanded from the topics, we skip the `claude -p` drafting loop
+    # entirely and just dedup + (maybe) supply-test + persist them. This is the
+    # single setup path on machines without the claude CLI. (2026-06-19)
+    if args.queries_json:
+        topics = _load_active_topics(project)  # best-effort, summary only
+        provided = _load_provided_queries(args.queries_json)
+        existing = (load_existing_query_cores(project)
+                    | _load_existing_seed_cores(project))
+        drafted = [(q, t) for q, t in provided
+                   if normalize_query(q) not in existing]
+        active_now = len(_fetch_active_queries(project))
+        print(f"seed_search_queries: project={project!r} mode=agent-supplied "
+              f"provided={len(provided)} new={len(drafted)} "
+              f"active_now={active_now} (no claude)", file=sys.stderr)
+        if not drafted:
+            # Everything provided was already seeded (or nothing usable) —
+            # healthy no-op: re-emit the live bank and succeed.
+            print(
+                f"seed_search_queries: project={project} topics={len(topics)} "
+                f"drafted=0 supply_ran=0 dropped_zero=0 seeded=0 inserted=0 "
+                f"updated=0 failed=0 (agent_supplied_nothing_new)"
+            )
+            if args.emit_json:
+                queries = _fetch_active_queries(project)
+                print("===QUERIES_JSON===")
+                print(json.dumps({"project": project, "count": len(queries),
+                                  "queries": queries}))
+            return 0
+    else:
+        topics = _load_active_topics(project)
+        if not topics:
+            print(f"seed_search_queries: no active topics for {project!r} — seed "
+                  f"topics first (scripts/seed_search_topics.py).", file=sys.stderr)
+            return 3
+
+        # Idempotency: aim for `target` TOTAL active queries, not `target` NEW per
+        # run. A project that already has >= target active seed queries needs no
+        # drafting — re-running reseed just re-emits the existing bank instead of
+        # ballooning it. Otherwise we only draft the shortfall. (2026-06-04)
+        active_now = len(_fetch_active_queries(project))
+        need = max(0, target - active_now)
+        per_topic = math.ceil(need / len(topics)) if need else 0
+        per_topic = max(MIN_PER_TOPIC, min(MAX_PER_TOPIC, per_topic)) if need else 0
+
+        # Dedup against (a) every query EVER attempted for this project and (b) seed
+        # queries already persisted. Accumulates as we go so topics don't overlap.
+        avoid_cores = load_existing_query_cores(project) | _load_existing_seed_cores(project)
+
+        print(f"seed_search_queries: project={project!r} topics={len(topics)} "
+              f"target={target} active_now={active_now} need={need} "
+              f"per_topic={per_topic} existing_cores={len(avoid_cores)}",
+              file=sys.stderr)
+
+        # --- Draft queries topic by topic ------------------------------------
+        drafted = []  # (query, topic)
+        for topic in topics:
+            if need <= 0 or len({normalize_query(q) for q, _ in drafted}) >= need:
+                break
+            prompt = build_query_prompt(
+                project_entry, topic, per_topic, avoid_queries=avoid_cores
+            )
+            try:
+                out = call_claude(prompt, timeout_sec=DRAFT_TIMEOUT_SEC)
+            except SystemExit as e:
+                print(f"[seed_search_queries] draft failed for topic {topic!r}: {e}",
+                      file=sys.stderr)
+                continue
+            qs = extract_queries(out, per_topic)
+            new_qs, dupes = dedup_queries(qs, avoid_cores)
+            for q in new_qs:
+                avoid_cores.add(normalize_query(q))
+                drafted.append((q, topic))
+            print(f"  topic={topic!r}: drafted={len(qs)} new={len(new_qs)} "
+                  f"dupes={len(dupes)}", file=sys.stderr)
 
     if not drafted:
         # Two cases: (a) the bank already meets target (need==0) — that's a