@m13v/s4l 1.7.9-rc.2 → 1.7.10-rc.1

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.9-rc.2",
-  "installedAt": "2026-08-09T00:22:23.419Z"
+  "version": "1.7.10-rc.1",
+  "installedAt": "2026-08-11T03:23:51.302Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.9-rc.2",
+  "version": "1.7.10-rc.1",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {
@@ -10,14 +10,17 @@
     "email": "i@m13v.com",
     "url": "https://s4l.ai"
   },
+  "compatibility": {
+    "platforms": [
+      "darwin"
+    ]
+  },
   "server": {
     "type": "node",
     "entry_point": "dist/index.js",
     "mcp_config": {
-      "command": "${__dirname}/vendor/node-darwin-arm64/bin/node",
-      "args": [
-        "${__dirname}/dist/index.js"
-      ],
+      "command": "${__dirname}/launch.js",
+      "args": [],
       "env": {
         "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
       }

package/mcp/menubar/s4l_browser_foreground.py

@@ -158,14 +158,12 @@ class _Worker(threading.Thread):
         # unaffected (CDP is offscreen-raster + synthetic input; the occlusion
         # flags keep hidden tabs painting).
         # DEFAULT ON (user decision 2026-08-07, reverses the 2026-07-30 default-off
-        # call): the guard hides an offscreen harness that steals the foreground
-        # unless explicitly opted out. Two knobs, by design:
-        #   S4L_NO_HARNESS_HIDE  -> HARD override, force off, checked FIRST so it
-        #       always wins (this is the one-time interactive-login escape hatch).
-        #   S4L_HARNESS_HIDE=0   -> SOFT opt-out for a machine that wants it off.
-        # Unset or any non-"0" value => hide is active (the new default).
-        if os.environ.get("S4L_NO_HARNESS_HIDE"):
-            return
+        # call). ONE flag by design (2026-08-08 — the old S4L_NO_HARNESS_HIDE
+        # override was removed to end the double-flag confusion):
+        #   S4L_HARNESS_HIDE unset / any value except "0" => hide active (default)
+        #   S4L_HARNESS_HIDE=0                            => disabled — the single
+        #       off switch (e.g. to keep a harness window visible for a one-time
+        #       interactive login, then set it back to 1 / unset it).
         if os.environ.get("S4L_HARNESS_HIDE", "1") == "0":
             return
         pos = details.get("window_position") or ""

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.9-rc.2",
+  "version": "1.7.10-rc.1",
   "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": "@m13v/s4l",
-  "version": "1.7.9-rc.2",
+  "version": "1.7.10-rc.1",
   "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/claude_job.py

@@ -16,8 +16,14 @@ docs/codex-port-design.md):
                         (_run_codex_exec; gpt-5.6-sol default, schema rides
                         the prompt — OpenAI strict schema mode rejects our
                         lenient schemas).
-
-All three return byte-identical claude `--output-format json` envelopes and
+  gemini-api            answer inline via the Gemini generateContent REST API
+                        (_run_gemini_api; gemini-pro-latest default with a
+                        one-shot flash downgrade on 404, schema rides the
+                        prompt for the same lenient-schema reason). The
+                        hosted-lane provider: key-authenticated, no local
+                        app, runs headless on Linux.
+
+All four return byte-identical claude `--output-format json` envelopes and
 the same 0/1/79 exit semantics, so callers can't tell them apart. The queue
 machinery below (next/result, worker notes, heartbeats) only runs for the
 default provider; the inline providers skip it entirely, which also means no
@@ -897,6 +903,160 @@ def _run_codex_exec(ns, qtype: str, prompt: str, schema_text: str | None) -> int
         _disarm_deathwatch(job_id)
 
 
+def _run_gemini_api(ns, qtype: str, prompt: str, schema_text: str | None) -> int:
+    """gemini-api provider: answer the turn inline via the Gemini
+    generateContent REST API. Key-authenticated, fully headless: this is the
+    hosted-lane provider (no Claude Desktop, no ChatGPT app, runs on Linux).
+    Same envelope, same 0/1/79 exit semantics as the other inline providers.
+
+    Schema rides the prompt (not responseSchema): Gemini's structured-output
+    schema dialect is an OpenAPI subset that rejects parts of our lenient
+    claude-style schemas, so _validate_against_schema stays the single gate,
+    matching the codex-exec precedent. responseMimeType application/json still
+    forces bare-JSON output for schema'd jobs; schemaless jobs (link-tail)
+    stay plain text.
+    """
+    import urllib.error
+    import urllib.request
+
+    key = draft_provider.gemini_api_key()
+    if not key:
+        _plog(f"gemini-api provider active but no GEMINI_API_KEY / keychain gemini-api-key; failing {qtype}")
+        return 1
+
+    batch = (os.environ.get("BATCH_ID") or os.environ.get("SA_CYCLE_ID") or "-").strip() or "-"
+    job_id = uuid.uuid4().hex
+    _arm_deathwatch(job_id, qtype, batch)
+    _act_write(qtype)
+    try:
+        if schema_text:
+            prompt = (
+                f"{prompt}\n\n"
+                "FINAL ANSWER FORMAT: reply with ONLY a JSON value matching this "
+                "JSON Schema. No prose, no markdown fences, nothing else:\n"
+                f"{schema_text}"
+            )
+        # Model default mirrors codex-exec's probe-by-use pattern: try the pro
+        # alias first (drafting quality is the product), downgrade ONCE to the
+        # flash alias on a model-not-found 404 and log it loudly. The -latest
+        # aliases are Google-maintained so this never pins a dead model id.
+        model = os.environ.get("S4L_GEMINI_MODEL", "").strip() or "gemini-pro-latest"
+        fallback_model = "gemini-flash-latest"
+        gen_config = {"temperature": 0.7, "maxOutputTokens": 16384}
+        if schema_text:
+            gen_config["responseMimeType"] = "application/json"
+        body = json.dumps(
+            {
+                "contents": [{"role": "user", "parts": [{"text": prompt}]}],
+                "generationConfig": gen_config,
+            }
+        ).encode()
+
+        budget = max(60, ns.timeout - 60)
+        _plog(f"gemini-api start {qtype} job {job_id} batch={batch} model={model} timeout={budget}s")
+        started = time.time()
+        resp_obj = None
+        for attempt_model in (model, fallback_model if fallback_model != model else None):
+            if not attempt_model:
+                break
+            url = (
+                "https://generativelanguage.googleapis.com/v1beta/models/"
+                f"{attempt_model}:generateContent"
+            )
+            req = urllib.request.Request(
+                url,
+                data=body,
+                headers={"Content-Type": "application/json", "x-goog-api-key": key},
+                method="POST",
+            )
+            try:
+                with urllib.request.urlopen(
+                    req, timeout=max(60, budget - int(time.time() - started))
+                ) as resp:
+                    resp_obj = json.loads(resp.read().decode())
+                break
+            except urllib.error.HTTPError as e:
+                tail = ""
+                try:
+                    tail = e.read().decode()[-400:]
+                except Exception:
+                    pass
+                if e.code == 404 and attempt_model == model:
+                    _plog(
+                        f"gemini-api model {attempt_model} not found (404); "
+                        f"retrying job {job_id} with {fallback_model}"
+                    )
+                    continue
+                _act_clear()
+                _plog(f"gemini-api HTTP {e.code} on job {job_id} ({qtype}); tail: {tail}")
+                return 1
+            except TimeoutError:
+                _act_clear()
+                _plog(f"gemini-api timed out after {budget}s on job {job_id} ({qtype})")
+                return 79  # mirror the queue path's "blocked, skip cleanly"
+            except Exception as e:
+                _act_clear()
+                _plog(f"gemini-api request failed on job {job_id} ({qtype}): {e}")
+                return 1
+        if resp_obj is None:
+            _act_clear()
+            _plog(f"gemini-api no response on job {job_id} ({qtype})")
+            return 1
+
+        try:
+            cand = resp_obj["candidates"][0]
+            text = "".join(
+                p.get("text", "") for p in cand.get("content", {}).get("parts", [])
+            ).strip()
+            finish = cand.get("finishReason", "?")
+        except (KeyError, IndexError, TypeError):
+            _act_clear()
+            block = (resp_obj.get("promptFeedback") or {}).get("blockReason", "?")
+            _plog(f"gemini-api no candidates on job {job_id} ({qtype}); blockReason={block}")
+            return 1
+        if not text:
+            _act_clear()
+            _plog(f"gemini-api empty answer on job {job_id} ({qtype}); finishReason={finish}")
+            return 1
+
+        # Same lenient parse as codex-exec: JSON when it parses, fenced JSON
+        # unwrapped, otherwise the raw text as a plain string (link-tail jobs).
+        obj = None
+        parsed = False
+        for candidate in (text, re.sub(r"^```(?:json)?\s*|\s*```$", "", text).strip()):
+            try:
+                obj = json.loads(candidate)
+                parsed = True
+                break
+            except Exception:
+                continue
+        if not parsed:
+            obj = text
+
+        err = _validate_against_schema(obj, schema_text)
+        if err:
+            _act_clear()
+            _plog(f"gemini-api result rejected for job {job_id} ({qtype}): {err}")
+            return 1
+
+        _emit_envelope(obj)
+        _mark_drain_success()
+        _stamp_heartbeat("gemini-api", qtype)
+        usage = resp_obj.get("usageMetadata") or {}
+        tokens = usage.get("totalTokenCount", "?")
+        try:
+            _ncand = len(obj.get("candidates")) if isinstance(obj, dict) and isinstance(obj.get("candidates"), list) else "?"
+        except Exception:
+            _ncand = "?"
+        _plog(
+            f"gemini-api done job {job_id} batch={batch} ({qtype}) in {int(time.time() - started)}s "
+            f"tokens={tokens} finish={finish}; {_ncand} candidates -> producer assembles the plan"
+        )
+        return 0
+    finally:
+        _disarm_deathwatch(job_id)
+
+
 def _run_claude_p(ns, qtype: str, prompt: str, schema_text: str | None) -> int:
     """claude-p provider: answer the turn inline via the real `claude -p`
     (Claude Code CLI, subscription-authenticated). No queue, no worker, no
@@ -999,6 +1159,8 @@ def cmd_provider(ns) -> int:
         return _run_codex_exec(ns, qtype, prompt, schema_text)
     if _prov == "claude-p":
         return _run_claude_p(ns, qtype, prompt, schema_text)
+    if _prov == "gemini-api":
+        return _run_gemini_api(ns, qtype, prompt, schema_text)
 
     job_id = uuid.uuid4().hex
     created = time.time()

package/scripts/draft_provider.py

@@ -18,6 +18,11 @@ Providers:
                         (headless, subscription-authenticated). Requires the
                         ChatGPT app installed and logged in. No queue, no
                         worker, no app-open requirement.
+  gemini-api            answer inline via the Gemini generateContent REST API
+                        (key-authenticated, no local app at all). The hosted
+                        lane's provider: works headless on any Linux box.
+                        Key: $GEMINI_API_KEY, else macOS keychain
+                        `gemini-api-key`.
 
 CLI:
   python3 scripts/draft_provider.py get            -> prints the active provider
@@ -32,7 +37,7 @@ import os
 import sys
 import time
 
-VALID_PROVIDERS = ("claude-desktop-queue", "claude-p", "codex-exec")
+VALID_PROVIDERS = ("claude-desktop-queue", "claude-p", "codex-exec", "gemini-api")
 DEFAULT_PROVIDER = "claude-desktop-queue"
 
 # The npm @openai/codex install is unreliable on macOS (XProtect false-positives
@@ -89,6 +94,27 @@ def codex_bin() -> str | None:
     return None
 
 
+def gemini_api_key() -> str | None:
+    """Resolved Gemini API key, or None. Env wins (the hosted/Linux path);
+    macOS keychain `gemini-api-key` is the operator-Mac fallback."""
+    key = os.environ.get("GEMINI_API_KEY", "").strip()
+    if key:
+        return key
+    try:
+        import subprocess
+
+        out = subprocess.run(
+            ["security", "find-generic-password", "-s", "gemini-api-key", "-w"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        key = (out.stdout or "").strip()
+        return key or None
+    except Exception:
+        return None
+
+
 def main() -> int:
     if len(sys.argv) < 2 or sys.argv[1] not in ("get", "set", "codex-bin"):
         print(__doc__, file=sys.stderr)

package/scripts/install.sh

@@ -32,7 +32,12 @@ log() { echo "[s4l-install] $*"; }
 die() { echo "[s4l-install] ERROR: $*" >&2; exit 1; }
 
 [ "$(uname -s)" = "Darwin" ] || die "macOS only for now."
-[ "$(uname -m)" = "arm64" ] || die "Apple Silicon only for now (the bundle vendors a darwin-arm64 Node)."
+# The bundle vendors both darwin-arm64 and darwin-x64 Node binaries (1.7.9+);
+# pick the one matching this machine.
+case "$(uname -m)" in
+  x86_64|amd64) NODE_ARCH="x64" ;;
+  *)            NODE_ARCH="arm64" ;;
+esac
 
 URL="$STABLE_URL"
 [ "${S4L_CHANNEL:-}" = "staging" ] && URL="$STAGING_URL"
@@ -45,7 +50,9 @@ log "downloading $URL"
 mkdir -p "$TMP/app"
 /usr/bin/unzip -q "$TMP/s4l.mcpb" -d "$TMP/app" || die "unzip failed"
 [ -f "$TMP/app/dist/index.js" ] || die "bundle missing dist/index.js (bad download?)"
-[ -x "$TMP/app/vendor/node-darwin-arm64/bin/node" ] || die "bundle missing vendored node"
+# Older bundles (pre-1.7.9) only vendor arm64; accept either so a staging box
+# pinned to an old release still installs on Apple Silicon.
+[ -x "$TMP/app/vendor/node-darwin-$NODE_ARCH/bin/node" ] || [ -x "$TMP/app/vendor/node-darwin-arm64/bin/node" ] || die "bundle missing vendored node for $NODE_ARCH"
 
 mkdir -p "$STATE_DIR"
 rm -rf "$APP_DIR.new"
@@ -55,7 +62,8 @@ mv "$APP_DIR.new" "$APP_DIR"
 rm -rf "$APP_DIR.old"
 log "installed bundle to $APP_DIR"
 
-NODE="$APP_DIR/vendor/node-darwin-arm64/bin/node"
+NODE="$APP_DIR/vendor/node-darwin-$NODE_ARCH/bin/node"
+[ -x "$NODE" ] || NODE="$APP_DIR/vendor/node-darwin-arm64/bin/node"
 SERVER="$APP_DIR/dist/index.js"
 SAFE_PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"