@m13v/s4l 1.6.197-rc.7

package/scripts/a16z_pearx_calendar_reminders.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""One-shot: create recurring accelerator-application reminders in
+matt@mediar.ai's Google Calendar via DWD (same SA as the gmail keepalive),
+requesting a calendar scope. If the scope isn't authorized in the mediar.ai
+Workspace DWD config, this fails with unauthorized_client and we fall back.
+"""
+import json, time, urllib.parse, urllib.request, urllib.error
+import google.auth
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+
+SA_EMAIL = "gmail-dwd-impersonator@gmail-api-integration-486018.iam.gserviceaccount.com"
+TARGET_USER = "matt@mediar.ai"
+SCOPE = "https://www.googleapis.com/auth/calendar"
+
+
+def mint_access_token():
+    creds, _ = google.auth.default(
+        scopes=["https://www.googleapis.com/auth/cloud-platform"]
+    )
+    creds.refresh(Request())
+    iat = int(time.time()); exp = iat + 3600
+    claim = {"iss": SA_EMAIL, "sub": TARGET_USER, "scope": SCOPE,
+             "aud": "https://oauth2.googleapis.com/token", "iat": iat, "exp": exp}
+    iam = build("iamcredentials", "v1", credentials=creds, cache_discovery=False)
+    signed = iam.projects().serviceAccounts().signJwt(
+        name=f"projects/-/serviceAccounts/{SA_EMAIL}",
+        body={"payload": json.dumps(claim)}).execute()
+    body = urllib.parse.urlencode({
+        "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        "assertion": signed["signedJwt"]}).encode()
+    req = urllib.request.Request("https://oauth2.googleapis.com/token", data=body,
+        headers={"Content-Type": "application/x-www-form-urlencoded"})
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read())["access_token"]
+    except urllib.error.HTTPError as e:
+        raise RuntimeError(f"token exchange {e.code}: {e.read().decode()}") from None
+
+
+def main():
+    from google.oauth2.credentials import Credentials
+    token = mint_access_token()
+    cal = build("calendar", "v3", credentials=Credentials(token=token),
+                cache_discovery=False)
+
+    events = [
+        {
+            "summary": "Apply to a16z Speedrun (next cohort) - S4L",
+            "start": "2026-09-15",
+            "rrule": "RRULE:FREQ=MONTHLY;INTERVAL=4",
+            "description": (
+                "Reapply S4L to a16z Speedrun. Speedrun runs ~3 cohorts/year; "
+                "this fires every 4 months so you catch the next deadline.\n\n"
+                "Apply: https://speedrun.a16z.com/apply (start with email i@m13v.com)\n"
+                "Status / update existing app: https://speedrun.a16z.com/application-login\n\n"
+                "Reuse the saved answer set (pitch, traction, funding, founder bio). "
+                "Last filled 2026-06-03; still need citizenship, university, years of "
+                "experience, last-round date, and the 3 investor emails."
+            ),
+        },
+        {
+            "summary": "Apply to PearX (next batch) - S4L",
+            "start": "2026-10-01",
+            "rrule": "RRULE:FREQ=MONTHLY;INTERVAL=6",
+            "description": (
+                "Reapply S4L to PearX. Pear runs 2 batches/year (summer + winter); "
+                "this fires every 6 months for the next window.\n\n"
+                "Apply: https://pear.vc/pearx-application/ (Airtable form; long-text "
+                "fields are contenteditable divs)\n\n"
+                "Reuse the saved answer set. PearX S26 app was filled 2026-06-03 "
+                "(left for review, not submitted)."
+            ),
+        },
+    ]
+
+    created = []
+    for ev in events:
+        body = {
+            "summary": ev["summary"],
+            "description": ev["description"],
+            "start": {"date": ev["start"]},
+            "end": {"date": ev["start"]},
+            "recurrence": [ev["rrule"]],
+            "reminders": {"useDefault": False, "overrides": [
+                {"method": "popup", "minutes": 24 * 60},
+                {"method": "email", "minutes": 24 * 60},
+            ]},
+            "transparency": "transparent",
+        }
+        out = cal.events().insert(calendarId="primary", body=body).execute()
+        created.append((ev["summary"], out.get("htmlLink")))
+
+    for s, link in created:
+        print(f"CREATED: {s}\n  {link}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/account_resolver.py

@@ -0,0 +1,141 @@
+"""Single source of truth for the posting account on every platform.
+
+Resolution order for each platform (first non-empty wins):
+
+  1. Env var `AUTOPOSTER_<PLATFORM>_HANDLE` (used by the VM / per-account
+     systemd or launchd units to override config.json without rewriting the
+     checked-in file). Twitter retains the legacy `AUTOPOSTER_TWITTER_HANDLE`
+     name as an alias.
+  2. The matching field in `config.json` -> `accounts.<platform>.<field>`.
+
+The handle is normalized:
+  - leading `@` is stripped (twitter)
+  - leading `u/` is stripped (reddit)
+  - surrounding whitespace is stripped
+So both `@matt_diak` and `matt_diak` resolve to `matt_diak`, both
+`u/Deep_Ad1959` and `Deep_Ad1959` resolve to `Deep_Ad1959`, matching the
+canonical shape stored in `posts.our_account` after the 2026-05-20 migration.
+
+Returns None if neither source has a value. Callers should treat None as
+"unknown account" and decline to scope per-account work that needs a handle
+(e.g. dedupe filters).
+
+Platform key map:
+    twitter   -> accounts.twitter.handle           (env: AUTOPOSTER_TWITTER_HANDLE)
+    reddit    -> accounts.reddit.username          (env: AUTOPOSTER_REDDIT_USERNAME)
+    linkedin  -> accounts.linkedin.name            (env: AUTOPOSTER_LINKEDIN_NAME)
+    github    -> accounts.github.username          (env: AUTOPOSTER_GITHUB_USERNAME)
+    moltbook  -> accounts.moltbook.username        (env: AUTOPOSTER_MOLTBOOK_USERNAME)
+"""
+from __future__ import annotations
+
+import json
+import os
+from functools import lru_cache
+from typing import Optional
+
+_PLATFORM_CONFIG_FIELD = {
+    "twitter":  ("twitter",  "handle"),
+    "x":        ("twitter",  "handle"),   # alias for the canonical post-platform
+    "reddit":   ("reddit",   "username"),
+    "linkedin": ("linkedin", "name"),
+    "github":   ("github",   "username"),
+    "moltbook": ("moltbook", "username"),
+}
+
+_PLATFORM_ENV_NAME = {
+    "twitter":  "AUTOPOSTER_TWITTER_HANDLE",
+    "x":        "AUTOPOSTER_TWITTER_HANDLE",
+    "reddit":   "AUTOPOSTER_REDDIT_USERNAME",
+    "linkedin": "AUTOPOSTER_LINKEDIN_NAME",
+    "github":   "AUTOPOSTER_GITHUB_USERNAME",
+    "moltbook": "AUTOPOSTER_MOLTBOOK_USERNAME",
+}
+
+
+def normalize(handle: Optional[str]) -> Optional[str]:
+    """Canonicalize a raw account handle.
+
+    Drops leading `@` (twitter) and `u/` (reddit) plus surrounding
+    whitespace. Returns None for empty input.
+    """
+    if not handle:
+        return None
+    h = handle.strip()
+    if h.startswith("@"):
+        h = h[1:]
+    elif h.lower().startswith("u/"):
+        h = h[2:]
+    h = h.strip()
+    return h or None
+
+
+@lru_cache(maxsize=1)
+def _load_config() -> dict:
+    repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    cfg_path = os.path.join(repo_root, "config.json")
+    try:
+        with open(cfg_path, "r", encoding="utf-8") as f:
+            return json.load(f) or {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def resolve(platform: str) -> Optional[str]:
+    """Return the normalized posting handle for `platform`, or None."""
+    key = (platform or "").strip().lower()
+    if key not in _PLATFORM_CONFIG_FIELD:
+        return None
+
+    env_name = _PLATFORM_ENV_NAME[key]
+    env_value = normalize(os.environ.get(env_name))
+    if env_value:
+        return env_value
+
+    section, field = _PLATFORM_CONFIG_FIELD[key]
+    cfg = _load_config()
+    accounts = cfg.get("accounts") or {}
+    block = accounts.get(section) or {}
+    return normalize(block.get(field))
+
+
+def require(platform: str) -> str:
+    """Like resolve() but raises if no handle is configured."""
+    h = resolve(platform)
+    if not h:
+        section, field = _PLATFORM_CONFIG_FIELD.get(
+            (platform or "").lower(), ("?", "?")
+        )
+        env_name = _PLATFORM_ENV_NAME.get(
+            (platform or "").lower(), f"AUTOPOSTER_{platform.upper()}_HANDLE"
+        )
+        raise RuntimeError(
+            f"No account configured for platform={platform!r}. "
+            f"Set env {env_name} or accounts.{section}.{field} in config.json."
+        )
+    return h
+
+
+# Backwards-compatible shim so the existing twitter-only call site keeps
+# working without churn. `from twitter_account import resolve_handle` will
+# continue to work; new code should call `account_resolver.resolve('twitter')`.
+def resolve_handle() -> Optional[str]:
+    return resolve("twitter")
+
+
+def require_handle() -> str:
+    return require("twitter")
+
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        plat = sys.argv[1]
+    else:
+        plat = "twitter"
+    h = resolve(plat)
+    if h:
+        sys.stdout.write(h + "\n")
+        sys.exit(0)
+    sys.stderr.write(f"no handle configured for platform={plat}\n")
+    sys.exit(1)

package/scripts/active_campaigns.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""Fetch active campaigns for a given platform with budget remaining.
+
+A campaign is "active" when:
+  - status = 'active'
+  - its platforms list includes the requested platform
+  - max_posts_total is set AND posts_made < max_posts_total
+
+Campaigns without max_posts_total are ignored by this script on purpose.
+Every campaign must declare a lifetime cap to be considered.
+
+Usage:
+    python3 active_campaigns.py --platform reddit          # prompt block (stdout)
+    python3 active_campaigns.py --platform reddit --json   # machine-readable
+"""
+
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+
+def _get_active_via_api(platform):
+    from http_api import api_get
+    resp = api_get(
+        "/api/v1/campaigns",
+        query={
+            "status": "active",
+            "platform": platform,
+            "with_budget_remaining": "true",
+            "limit": 500,
+        },
+    )
+    rows = ((resp or {}).get("data") or {}).get("campaigns") or []
+    out = []
+    for r in rows:
+        max_total = r.get("max_posts_total")
+        posts_made = r.get("posts_made") or 0
+        if max_total is None or posts_made >= max_total:
+            continue
+        out.append({
+            "id": int(r["id"]),
+            "name": r.get("name"),
+            "prompt": r.get("prompt"),
+            "max_posts_total": int(max_total),
+            "posts_made": int(posts_made),
+            "remaining": int(max_total) - int(posts_made),
+        })
+    return out
+
+
+def get_active_campaigns(platform):
+    """Active campaigns for `platform` with budget remaining.
+
+    Routes through /api/v1/campaigns (HTTP-only).
+    """
+    return _get_active_via_api(platform)
+
+
+def format_prompt_block(campaigns, repo_dir):
+    if not campaigns:
+        return ""
+
+    ids_csv = ",".join(str(c["id"]) for c in campaigns)
+    lines = []
+    lines.append("## ACTIVE CAMPAIGNS (mandatory for every post this run)")
+    lines.append("")
+    lines.append("The following campaign instructions override your defaults. Follow them exactly.")
+    lines.append("")
+
+    for c in campaigns:
+        lines.append(f"### CAMPAIGN id={c['id']} name={c['name']}")
+        lines.append(f"Lifetime budget: {c['remaining']} of {c['max_posts_total']} posts remaining.")
+        lines.append("Instruction:")
+        lines.append(c["prompt"])
+        lines.append("")
+
+    lines.append("## REQUIRED campaign attribution (do this for EVERY post you create)")
+    lines.append("")
+    lines.append("1. When inserting the post row, use `INSERT INTO posts (...) VALUES (...) RETURNING id;` to capture NEW_POST_ID.")
+    lines.append("2. Immediately after, run this shell command to attach the post to the active campaigns:")
+    lines.append("")
+    lines.append(f"   python3 {repo_dir}/scripts/campaign_bump.py --post-id NEW_POST_ID --campaign-ids {ids_csv}")
+    lines.append("")
+    lines.append("This is mandatory. If you skip it, the campaign counter does not advance and the campaign will over-post.")
+    return "\n".join(lines)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--platform", required=True)
+    ap.add_argument("--json", action="store_true")
+    ap.add_argument("--repo-dir", default=os.path.expanduser("~/social-autoposter"))
+    args = ap.parse_args()
+
+    campaigns = get_active_campaigns(args.platform)
+
+    if args.json:
+        print(json.dumps({
+            "platform": args.platform,
+            "active_count": len(campaigns),
+            "campaign_ids": ",".join(str(c["id"]) for c in campaigns),
+            "campaigns": campaigns,
+        }))
+    else:
+        block = format_prompt_block(campaigns, args.repo_dir)
+        if block:
+            print(block)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/active_users.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Who is actually using social-autoposter right now.
+
+Reads the `installations` heartbeat table (the only live per-install signal) and
+answers "how many real, external people are active" without the inflation that a
+raw install count carries:
+
+  * install_id is per identity.json, NOT per machine. A reinstall / reset / each
+    ephemeral mk0r E2B sandbox mints a fresh id. So we dedupe by `hardware_uuid`
+    (the stable per-machine key) and report MACHINES, not install rows.
+  * Our own infra (i@m13v.com operator Mac, the agent@mk0r.com / e2b.local VM
+    fleet) is filtered out by default so the roster is real customers. Pass
+    --all to include it.
+  * Cross-references the `posts` table so you can see the alive-but-not-posting
+    gap (the blind spot the Cloud Logging stream exists to explain).
+
+Usage:
+  python3 scripts/active_users.py                 # external machines, last 7d
+  python3 scripts/active_users.py --days 30        # different window
+  python3 scripts/active_users.py --all            # include our own infra
+  python3 scripts/active_users.py --json           # machine-readable
+
+Operator-local only: uses the direct-Postgres lane via scripts/db.py (absent in
+the shipped npm package), reading DATABASE_URL from ~/social-autoposter/.env.
+"""
+
+import argparse
+import json
+import os
+import sys
+from urllib.parse import unquote
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from db import load_env, get_conn  # noqa: E402
+
+# Our own installs, hidden by default so the roster is real external users.
+INTERNAL_EMAILS = {"i@m13v.com", "agent@mk0r.com", "matt@mediar.ai"}
+INTERNAL_HOSTNAME_SUBSTR = ("e2b.local", "71522")  # mk0r E2B sandboxes; MacStadium QA box
+# MacStadium remote QA box (hostname "71522", no git_email). It actively runs the
+# pipeline and posts, so without this it masquerades as our only posting customer.
+INTERNAL_HARDWARE_UUIDS = {"07CB793D-6E32-5EF8-82E2-7CDEABD47FBC"}
+
+# Connected X handle resolves only from posts.our_account; drop scaffolding values.
+PLACEHOLDER_HANDLES = {"your-twitter-handle", "your_handle", "your-handle", "none", "null", ""}
+
+
+def parse_handles(raw):
+    out = []
+    for h in (raw or "").split(","):
+        h = h.strip().lstrip("@")
+        if h and h.lower() not in PLACEHOLDER_HANDLES and h not in out:
+            out.append(h)
+    return out
+
+
+def is_internal(emails, hostnames, hardware_uuids):
+    if any((e or "").lower() in INTERNAL_EMAILS for e in emails):
+        return True
+    if any(sub in (h or "") for h in hostnames for sub in INTERNAL_HOSTNAME_SUBSTR):
+        return True
+    if any((u or "") in INTERNAL_HARDWARE_UUIDS for u in hardware_uuids):
+        return True
+    return False
+
+
+def fetch(days):
+    # One row per MACHINE (hardware_uuid; fall back to a per-install key when the
+    # client never reported a hardware_uuid so those installs aren't all merged).
+    # `days` is an argparse int (injection-safe), inlined because the wrapper's
+    # SQL translation mangles %s placeholders.
+    days = int(days)
+    q = f"""
+    WITH win AS (
+      SELECT *,
+             COALESCE(NULLIF(git_email, ''), NULLIF(hardware_uuid, ''),
+                      'anon:' || install_id::text) AS entity_key
+      FROM installations
+      WHERE last_seen_at > now() - interval '{days} days'
+    ),
+    posted AS (
+      SELECT install_id, count(*) AS n
+      FROM posts
+      WHERE posted_at > now() - interval '{days} days' AND install_id IS NOT NULL
+      GROUP BY install_id
+    ),
+    handles AS (
+      -- The connected X handle is NOT in the heartbeat; it only reaches the
+      -- central DB via posts.our_account, so it exists ONLY for installs that
+      -- ever posted (all-time, not windowed: a handle is identity, not activity).
+      SELECT install_id, string_agg(DISTINCT our_account, ',') AS hs
+      FROM posts
+      WHERE our_account IS NOT NULL AND length(trim(our_account)) > 0
+      GROUP BY install_id
+    )
+    SELECT
+      w.entity_key,
+      count(DISTINCT w.install_id)                                            AS installs,
+      count(DISTINCT w.hardware_uuid)                                         AS machines,
+      array_remove(array_agg(DISTINCT w.hardware_uuid), NULL)                 AS hardware_uuids,
+      array_remove(array_agg(DISTINCT NULLIF(w.git_email, '')), NULL)         AS emails,
+      array_remove(array_agg(DISTINCT w.hostname), NULL)                      AS hostnames,
+      string_agg(DISTINCT h.hs, ',')                                          AS handles_raw,
+      max(w.os_version)                                                       AS os,
+      array_remove(array_agg(DISTINCT
+        w.last_country || '/' || COALESCE(w.last_city, '-')), NULL)           AS locations,
+      max(w.last_seen_at)                                                     AS last_seen,
+      COALESCE(sum(p.n), 0)                                                   AS posts
+    FROM win w
+    LEFT JOIN posted p  ON p.install_id = w.install_id
+    LEFT JOIN handles h ON h.install_id = w.install_id
+    GROUP BY w.entity_key
+    ORDER BY last_seen DESC;
+    """
+    conn = get_conn()
+    try:
+        cur = conn.execute(q)
+        cols = [c.name for c in cur.description]
+        return [dict(zip(cols, row)) for row in cur.fetchall()]
+    finally:
+        conn.close()
+
+
+def person(row):
+    if row["emails"]:
+        return row["emails"][0]
+    if row["hostnames"]:
+        return row["hostnames"][0]
+    return row["entity_key"][:12]
+
+
+def loc(row):
+    return ", ".join(unquote(x) for x in (row["locations"] or [])) or "?"
+
+
+def main():
+    ap = argparse.ArgumentParser(
+        description="Active social-autoposter users, deduped per person (email, else machine).")
+    ap.add_argument("--days", type=int, default=7, help="lookback window in days (default 7)")
+    ap.add_argument("--all", action="store_true", help="include our own infra (i@m13v / mk0r)")
+    ap.add_argument("--json", action="store_true", help="emit JSON")
+    args = ap.parse_args()
+
+    load_env()
+    rows = fetch(args.days)
+    for r in rows:
+        r["internal"] = is_internal(r["emails"], r["hostnames"], r["hardware_uuids"])
+        r["handles"] = parse_handles(r.get("handles_raw"))
+
+    external = [r for r in rows if not r["internal"]]
+    internal = [r for r in rows if r["internal"]]
+    shown = rows if args.all else external
+
+    if args.json:
+        out = [{
+            "person": person(r), "x_handles": r["handles"], "machines": r["machines"],
+            "installs": r["installs"], "hostnames": r["hostnames"], "emails": r["emails"],
+            "os": r["os"], "location": loc(r), "posts": int(r["posts"]),
+            "last_seen": r["last_seen"].isoformat() if r["last_seen"] else None,
+            "internal": r["internal"],
+        } for r in shown]
+        print(json.dumps({
+            "window_days": args.days,
+            "external_machines": len(external),
+            "external_people": len({e for r in external for e in r["emails"]}),
+            "internal_machines_hidden": 0 if args.all else len(internal),
+            "rows": out,
+        }, indent=2))
+        return
+
+    people = len({e for r in external for e in r["emails"]})
+    print(f"\nActive in last {args.days}d: {len(external)} external machines "
+          f"(~{people} identified people){'' if args.all else f', {len(internal)} internal hidden'}\n")
+    hdr = (f"{'PERSON':<30} {'X HANDLE':<16} {'HOST':<22} {'OS':<7} {'LOC':<16} "
+           f"{'INST':>4} {'POSTS':>6}  LAST SEEN")
+    print(hdr)
+    print("-" * len(hdr))
+    for r in shown:
+        tag = "  [internal]" if r["internal"] else ""
+        host = (r["hostnames"][0] if r["hostnames"] else "?")[:22]
+        handle = (", ".join(r["handles"]) or "-")[:16]
+        print(f"{person(r)[:30]:<30} {handle:<16} {host:<22} {(r['os'] or '?'):<7} "
+              f"{loc(r)[:16]:<16} {r['installs']:>4} {int(r['posts']):>6}  "
+              f"{r['last_seen']:%Y-%m-%d %H:%M}{tag}")
+    posting = sum(1 for r in external if r["posts"] > 0)
+    print(f"\n  of {len(external)} external machines, {posting} posted in the window, "
+          f"{len(external) - posting} are alive-but-not-posting.\n")
+
+
+if __name__ == "__main__":
+    main()