social-autoposter 1.6.20 → 1.6.22

package/bin/cli.js

@@ -453,15 +453,38 @@ function installBrowserHarness() {
       console.warn('    WARNING: git clone failed; twitter-harness will not work until you clone manually.');
     }
   } else {
-    console.log(`    browser-harness clone exists -> ${harnessDir}`);
+    // Refresh the existing clone instead of silently reusing it. server.py
+    // invokes `browser-harness -c <script>`; a stale checkout that predates the
+    // `-c` interface (or otherwise drifted from upstream) makes every bh_run
+    // return the CLI usage string while looking "installed". fetch+reset --hard
+    // to current upstream so the installed CLI always matches the shipped
+    // server.py contract.
+    console.log(`    browser-harness clone exists -> ${harnessDir}; updating to latest...`);
+    const fetch = spawnSync('git', ['-C', harnessDir, 'fetch', '--depth', '1', 'origin', 'HEAD'], { stdio: 'inherit' });
+    if (fetch.status === 0) {
+      const reset = spawnSync('git', ['-C', harnessDir, 'reset', '--hard', 'FETCH_HEAD'], { stdio: 'inherit' });
+      if (reset.status !== 0) {
+        console.warn('    WARNING: could not reset browser-harness clone to latest; using existing checkout.');
+      }
+    } else {
+      console.warn('    WARNING: could not fetch browser-harness updates; using existing checkout.');
+    }
   }
 
   if (uvBin && fs.existsSync(harnessDir)) {
     console.log('    installing browser-harness CLI via uv tool...');
-    const install = spawnSync(uvBin, ['tool', 'install', '-e', harnessDir], { stdio: 'inherit' });
+    // --force so a refreshed source / changed entry point is reinstalled even
+    // when the tool is already present (a plain re-install is otherwise a no-op).
+    const install = spawnSync(uvBin, ['tool', 'install', '--force', '-e', harnessDir], { stdio: 'inherit' });
     if (install.status !== 0) {
       console.warn('    WARNING: `uv tool install -e .` failed; check the output above.');
     }
+    // The harness daemon caches imported code in a long-running process; drop it
+    // so the next bh_run loads the freshly-installed CLI instead of stale code.
+    const harnessBin = path.join(HOME, '.local', 'bin', 'browser-harness');
+    if (fs.existsSync(harnessBin)) {
+      spawnSync(harnessBin, ['--reload'], { stdio: 'inherit' });
+    }
   }
 
   // Step 4: ensure mcp Python package available (server.py uses `from mcp.server.fastmcp ...`).

package/mcp-servers/browser-harness/server.py

@@ -261,17 +261,62 @@ def ensure_chrome() -> dict:
     }
 
 
+def _port_owner_pids() -> list[int]:
+    """PIDs LISTENing on our debug PORT, via lsof. Lets stop_chrome reap a Chrome
+    that another launcher (e.g. setup_twitter_auth.py's connect_x) started without
+    writing PID_FILE, instead of stranding an un-reapable orphan that makes
+    bh_start keep reporting 'already_running'. Returns [] if lsof is unavailable."""
+    try:
+        out = subprocess.run(
+            ["lsof", "-ti", f"tcp:{PORT}", "-sTCP:LISTEN"],
+            capture_output=True, text=True, timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
+    pids = []
+    for tok in (out.stdout or "").split():
+        try:
+            pids.append(int(tok))
+        except ValueError:
+            pass
+    return pids
+
+
+def _terminate(pid: int, grace: float = 5.0) -> None:
+    """SIGTERM, then SIGKILL only if still alive after `grace` seconds. The wait
+    gives Chrome time to flush its in-memory cookie store to the on-disk profile,
+    so a stop->start restart preserves the X session instead of coming back
+    logged out (the failure the setup agent hit after a hard kill)."""
+    try:
+        os.kill(pid, 15)
+    except OSError:
+        return
+    deadline = time.time() + grace
+    while time.time() < deadline:
+        if not _pid_alive(pid):
+            return
+        time.sleep(0.2)
+    try:
+        os.kill(pid, 9)
+    except OSError:
+        pass
+
+
 def stop_chrome() -> dict:
-    """Kill the managed Chrome instance, if any."""
+    """Gracefully stop the managed Chrome — the tracked process AND any orphan
+    still LISTENing on the debug port — so connect_x-launched Chromes can't
+    strand the port. SIGTERM-with-grace lets Chrome persist cookies to disk."""
+    targets: list[int] = []
     pid = _read_pid()
     if pid and _pid_alive(pid):
-        try:
-            os.kill(pid, 15)
-            time.sleep(0.6)
-            if _pid_alive(pid):
-                os.kill(pid, 9)
-        except OSError as e:
-            return {"status": "error", "error": str(e), "pid": pid}
+        targets.append(pid)
+    for owner in _port_owner_pids():
+        if owner not in targets and _pid_alive(owner):
+            targets.append(owner)
+
+    for t in targets:
+        _terminate(t)
+
     try:
         PID_FILE.unlink()
     except FileNotFoundError:
@@ -281,7 +326,7 @@ def stop_chrome() -> dict:
             os.unlink(stale)
         except FileNotFoundError:
             pass
-    return {"status": "stopped", "pid": pid}
+    return {"status": "stopped", "reaped": targets, "tracked_pid": pid}
 
 
 # --- browser-harness exec wrapper ---
@@ -375,12 +420,16 @@ def bh_run(script: str, timeout: int = EXEC_TIMEOUT_SEC) -> str:
 def bh_status() -> str:
     """Report whether the managed Chrome is alive and where it lives."""
     pid = _read_pid()
+    owners = _port_owner_pids()
     return json.dumps(
         {
             "cdp_url": CDP_URL,
             "cdp_alive": _cdp_alive(),
             "chrome_pid": pid,
-            "chrome_alive": pid is not None and _pid_alive(pid),
+            "chrome_alive": (pid is not None and _pid_alive(pid)) or _cdp_alive(),
+            # Untracked Chromes (e.g. launched by connect_x) show up here even
+            # when chrome_pid is null — that's the orphan that bh_stop now reaps.
+            "port_owner_pids": owners,
             "profile_dir": str(PROFILE_DIR),
             "log_file": str(LOG_FILE),
             "harness_bin": BROWSER_HARNESS_BIN,
@@ -400,10 +449,26 @@ def bh_start() -> str:
 
 @mcp.tool()
 def bh_stop() -> str:
-    """Kill the managed Chrome instance. Cookies/profile data persist on disk."""
+    """Kill the managed Chrome instance. Cookies/profile data persist on disk.
+
+    Reaps both the tracked process and any orphan still holding the debug port,
+    using a graceful SIGTERM-with-grace so cookies flush to disk first."""
     return json.dumps(stop_chrome(), indent=2)
 
 
+@mcp.tool()
+def bh_restart() -> str:
+    """Flush + restart the managed Chrome in one step. Gracefully stops it (so
+    Chrome persists the cookie store to disk and any port-orphan is reaped), then
+    starts a fresh instance that loads the just-flushed session from disk. Use
+    this instead of killing Chrome by hand — a hard kill drops the in-memory X
+    session before it is written, which is what forces a re-login."""
+    stopped = stop_chrome()
+    time.sleep(0.5)
+    started = ensure_chrome()
+    return json.dumps({"status": "restarted", "stopped": stopped, "started": started}, indent=2)
+
+
 @mcp.tool()
 def bh_seed_cookies(source: str = "chrome:Default", domains: str | None = None) -> str:
     """Import cookies from a local browser profile into the managed Chrome.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-autoposter",
-  "version": "1.6.20",
+  "version": "1.6.22",
   "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/setup_twitter_auth.py

@@ -63,12 +63,27 @@ except ImportError:
     )
     sys.exit(0)
 
+# Optional server-side session-cookie store (best-effort). Lets connect_x persist
+# the validated X cookies so restore_twitter_session.py can auto-re-inject them
+# after any logout. Guarded so a missing dep or offline API never breaks setup.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+try:
+    from http_api import api_post  # noqa: E402
+    from twitter_account import resolve_handle  # noqa: E402
+except Exception:
+    api_post = None
+    resolve_handle = None
+
 # --- Config -----------------------------------------------------------------
 
 # Same managed Chrome the twitter-harness pipeline uses (skill/lib/twitter-backend.sh).
 CDP = os.environ.get("SAPS_TWITTER_CDP_URL", os.environ.get("TWITTER_CDP_URL", "http://127.0.0.1:9555")).rstrip("/")
 PORT = int(CDP.rsplit(":", 1)[-1]) if CDP.rsplit(":", 1)[-1].isdigit() else 9555
 PROFILE_DIR = Path.home() / ".claude" / "browser-profiles" / "browser-harness"
+# Same PID file server.py (the twitter-harness MCP) writes, so a Chrome launched
+# here is tracked and reapable by bh_stop instead of becoming an orphan that
+# strands the debug port.
+PID_FILE = Path.home() / ".claude" / "browser-profiles" / "browser-harness.chrome.pid"
 
 # Browsers ai_browser_profile.cookies can read from, in auto-detect priority.
 AUTO_SOURCES = ["chrome:Default", "arc:Default", "brave:Default", "edge:Default"]
@@ -163,7 +178,11 @@ def _launch_chrome() -> bool:
         cmd += ["--window-position=80,80", "--window-size=1100,900"]
     cmd.append("about:blank")
     PROFILE_DIR.mkdir(parents=True, exist_ok=True)
-    subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    try:
+        PID_FILE.write_text(str(proc.pid))
+    except OSError:
+        pass
     for _ in range(15):
         if _cdp_alive():
             return True
@@ -258,6 +277,50 @@ def _has_session_quick() -> bool:
             pass
 
 
+def _save_session_to_store() -> None:
+    """Best-effort: persist the live x.com cookies to the server-side session
+    store (social_accounts.session_cookies, via POST /api/v1/twitter/session-cookies)
+    so restore_twitter_session.py can auto-re-inject them on the next preflight
+    after ANY logout — hard kill, crash, or AppMaker VM reseed. Non-fatal: the
+    local session is already valid; this only enables future auto-recovery.
+    Without it the restore rail has nothing to read and every logout needs a
+    manual connect_x."""
+    if api_post is None or resolve_handle is None:
+        return
+    try:
+        handle = resolve_handle()
+    except Exception:
+        handle = None
+    if not handle:
+        return
+    try:
+        ws, send = _attach()
+    except Exception:
+        return
+    try:
+        send("Network.enable")
+        r = send("Network.getAllCookies")
+        cks = r.get("result", {}).get("cookies", []) or []
+        wanted = tuple(d.strip() for d in DOMAINS.split(",") if d.strip())
+        cookies = [c for c in cks if any(w in (c.get("domain") or "") for w in wanted)]
+        if not cookies:
+            return
+        api_post("/api/v1/twitter/session-cookies", {"handle": handle, "cookies": cookies})
+        print(f"setup_twitter_auth: saved {len(cookies)} session cookies for @{handle} "
+              "(auto-restore enabled)", file=sys.stderr)
+    # api_post raises SystemExit (BaseException, NOT Exception) on a 4xx/5xx —
+    # e.g. "no social_accounts row" on a persistent machine that never registered
+    # this handle. The save is best-effort and must never abort connect_x, so
+    # catch SystemExit too.
+    except (Exception, SystemExit) as e:
+        print(f"setup_twitter_auth: session-store save skipped ({e})", file=sys.stderr)
+    finally:
+        try:
+            ws.close()
+        except Exception:
+            pass
+
+
 def _show_window_and_open_login() -> bool:
     """Make the managed Chrome window VISIBLE + focused and land it on the X login
     page, so the user can sign in by hand (the manual-login fallback).
@@ -387,6 +450,7 @@ def cmd_connect(args) -> dict:
     # 1. Already logged in? Nothing to import.
     try:
         if _is_session_valid():
+            _save_session_to_store()
             return {
                 "ok": True,
                 "connected": True,
@@ -410,6 +474,7 @@ def cmd_connect(args) -> dict:
         # 3. Re-validate after this source.
         try:
             if _is_session_valid():
+                _save_session_to_store()
                 return {
                     "ok": True,
                     "connected": True,

package/skill/run-twitter-cycle.sh

@@ -75,22 +75,34 @@ export SA_CYCLE_ID="$BATCH_ID"
 #   control   = generic "keep it tight" guidance, no per-style number, no gate
 #               (reproduces pre-length-project length behavior WITHOUT reverting
 #                the bug fixes shipped alongside the length project)
-# Assignment is deterministic from BATCH_ID (md5 low bit) so a re-run of the
-# same cycle id lands the same arm. Set LENGTH_AB_ENABLED=0 to disable the
-# experiment: every cycle then runs treatment (full length-control behavior).
+# Assignment is deterministic from BATCH_ID's trailing timestamp digit (parity)
+# so a re-run of the same cycle id lands the same arm. Set LENGTH_AB_ENABLED=0
+# to disable the experiment: every cycle then runs treatment (full length
+# control behavior).
+#
+# DO NOT switch this back to md5/md5sum. Those binaries live in /sbin on macOS
+# (and /usr/bin/md5sum-only on Linux), and /sbin is NOT on the launchd PATH
+# (node/bin:/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin). On 2026-06-02 an
+# md5-based split silently produced an EMPTY hash under cron, fell through the
+# case to control, and stamped 173/173 control in 12h (a dead experiment that
+# looked alive). tr + tail live in /usr/bin (on the launchd PATH, and present
+# on both macOS and the Linux VMs), so the digit split is PATH- and platform-
+# safe. Empty/garbage fails OPEN to treatment (full length behavior), never
+# silently to one arm.
 LENGTH_AB_ENABLED="${LENGTH_AB_ENABLED:-1}"
 if [ "$LENGTH_AB_ENABLED" = "1" ]; then
-  _len_hash=$(printf '%s' "$BATCH_ID" | md5 2>/dev/null || printf '%s' "$BATCH_ID" | md5sum | awk '{print $1}')
-  _len_last=$(printf '%s' "$_len_hash" | tail -c 1)
+  _len_digits=$(printf '%s' "$BATCH_ID" | tr -cd '0-9')
+  _len_last=$(printf '%s' "$_len_digits" | tail -c 1)
   case "$_len_last" in
-    [02468ace]) LENGTH_ARM="treatment" ;;
-    *)          LENGTH_ARM="control" ;;
+    [13579]) LENGTH_ARM="treatment" ;;
+    [02468]) LENGTH_ARM="control" ;;
+    *)       LENGTH_ARM="treatment" ;;
   esac
 else
   LENGTH_ARM="treatment"
+  _len_last="off"
 fi
 export LENGTH_ARM
-echo "[length-ab] LENGTH_AB_ENABLED=$LENGTH_AB_ENABLED arm=$LENGTH_ARM batch=$BATCH_ID" >&2
 
 LOG_FILE="$LOG_DIR/twitter-cycle-$(date +%Y-%m-%d_%H%M%S).log"
 RAW_FILE="/tmp/twitter_cycle_raw_$(date +%s).json"
@@ -112,7 +124,12 @@ TW_ENGINE_PREFIX=""
 # Tweets older than this are no longer worth replying to. Pending rows older
 # than this are hard-expired by Phase 0; younger pending rows are salvaged
 # from prior cycles into this batch.
-FRESHNESS_HOURS=6
+# 2026-06-01: tightened 6h -> 2h. The pending pool had bloated to 636 rows,
+# 523 of them >6h old (median virality 0.44, far below the ~5.8 posted median),
+# because the salvage loop kept re-carrying stale low-virality junk. A 2h
+# ceiling drops that carry runway so aged-out junk expires instead of riding
+# ~80 cycles. Discovery is already capped at 1h (FRESHNESS_HOURS_DISCOVER).
+FRESHNESS_HOURS=2
 
 # ----------------------------------------------------------------------------
 # EXPERIMENT CONCLUDED 2026-05-31: variant D won the ripen+freshness A/B/C/D
@@ -124,10 +141,10 @@ FRESHNESS_HOURS=6
 # permanent, hardcoded behavior. The cycle_variant column is still stamped 'D'
 # below so historical analytics keep a consistent label.
 #
-# Phase 0 hard-expire continues to use FRESHNESS_HOURS=6 (the union ceiling) so
-# peer cycles don't accidentally expire each other's still-pending rows. Only
-# FRESHNESS_HOURS_DISCOVER (Phase 1 prompt + since-rewrite hook) is tightened to
-# 1h, which was the winning D setting.
+# Phase 0 hard-expire uses FRESHNESS_HOURS (the union ceiling, tightened to 2h
+# on 2026-06-01, see above) so peer cycles don't accidentally expire each
+# other's still-pending rows. FRESHNESS_HOURS_DISCOVER (Phase 1 prompt +
+# since-rewrite hook) stays tightened to 1h, the winning D setting.
 TWITTER_CYCLE_VARIANT=D
 FRESHNESS_HOURS_DISCOVER=1
 export TWITTER_CYCLE_VARIANT FRESHNESS_HOURS_DISCOVER
@@ -150,6 +167,7 @@ log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$LOG_FILE"; }
 
 log "=== Twitter Cycle (batch=$BATCH_ID): $(date) ==="
 log "Logic=D (no-ripen + 1h freshness + 2k_view_cap; experiment concluded 2026-05-31); discover_freshness=${FRESHNESS_HOURS_DISCOVER}h"
+log "[length-ab] enabled=$LENGTH_AB_ENABLED arm=$LENGTH_ARM (batch=$BATCH_ID, last_digit=${_len_last:-none})"
 
 # --- Preflight (added 2026-05-02) -----------------------------------------
 # Three early-exit gates BEFORE we open the DB, set up traps, or touch the