@m13v/s4l 1.6.197-rc.10

package/scripts/send_web_chat_reply.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Send a founder reply on a web-chat thread (HTTP-only DB layer).
+
+Mirror of ~/fazm/inbox/scripts/send-chat-reply.js. The DB work (dedup guard,
+insert the agent/founder message, mark visitor messages read, bump thread
+metadata) runs through POST /api/v1/web-chat/threads/<id>/reply. The Resend
+email forward to the visitor stays local (send-email.js), and the resulting
+Resend id is stamped back onto the message via PATCH
+/api/v1/web-chat/messages/<id>.
+
+Dedup guard (server-side): skip if a founder/agent message was already sent in
+the last 60 seconds (matches Fazm behaviour).
+
+Usage:
+  python3 send_web_chat_reply.py --thread <thread_id> --text "reply" [--name "matt"]
+                                 [--sender agent|founder] [--no-email]
+                                 [--ingested-gmail-id <gmail_id>]
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_post, api_patch
+
+SEND_EMAIL_SCRIPT = os.path.expanduser("~/analytics/scripts/send-email.js")
+NODE_BIN = os.path.expanduser("~/.nvm/versions/node/v20.19.4/bin/node")
+NODE_PATH = os.path.expanduser("~/analytics/node_modules")
+
+
+def project_config(project_name):
+    """Read the project entry from ~/social-autoposter/config.json."""
+    import json
+
+    cfg_path = os.path.expanduser("~/social-autoposter/config.json")
+    with open(cfg_path) as f:
+        cfg = json.load(f)
+    for p in cfg.get("projects", []):
+        if p.get("name") == project_name:
+            return p
+    return {}
+
+
+def email_visitor(visitor_email, project_name, text, project_cfg):
+    """Forward founder reply to visitor's email via Resend (send-email.js)."""
+    if not visitor_email or not SEND_EMAIL_SCRIPT or not os.path.exists(SEND_EMAIL_SCRIPT):
+        return None
+
+    web_chat_cfg = (project_cfg or {}).get("web_chat", {}) or {}
+    from_email = web_chat_cfg.get("from_email") or "Matt <matt@mail.omi.me>"
+    site_pretty = (project_cfg.get("website") or "").replace("https://", "").replace("http://", "").rstrip("/")
+    subject = f"re: your message on {site_pretty}" if site_pretty else "re: your message"
+
+    env = os.environ.copy()
+    env.setdefault("NODE_PATH", NODE_PATH)
+
+    args = [
+        NODE_BIN, SEND_EMAIL_SCRIPT,
+        "--to", visitor_email,
+        "--subject", subject,
+        "--body", text,
+        "--from", from_email,
+        "--no-db",  # web_chat has its own DB rail
+    ]
+    try:
+        result = subprocess.run(args, env=env, capture_output=True, text=True, timeout=30)
+        # send-email.js prints "Sent! Resend ID: <id>"
+        for line in (result.stdout or "").splitlines():
+            if "Resend ID:" in line:
+                return line.split("Resend ID:")[-1].strip()
+    except Exception as e:
+        print(f"  WARN: visitor email send failed: {e}", file=sys.stderr)
+    return None
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--thread", required=True)
+    parser.add_argument("--text", required=True)
+    parser.add_argument("--name", default="matt")
+    parser.add_argument("--sender", default="agent", choices=["agent", "founder"])
+    parser.add_argument("--no-email", action="store_true",
+                        help="Skip Resend forward to visitor (used when ingest already emailed)")
+    parser.add_argument("--ingested-gmail-id", default=None,
+                        help="Stamp this Gmail id on the inserted message (Gmail-ingest rail dedup)")
+    args = parser.parse_args()
+
+    # 1-3 (dedup + insert + mark-read + bump) all happen server-side.
+    body = {
+        "text": args.text,
+        "name": args.name,
+        "sender": args.sender,
+    }
+    if args.ingested_gmail_id:
+        body["ingested_gmail_id"] = args.ingested_gmail_id
+
+    resp = api_post(
+        f"/api/v1/web-chat/threads/{args.thread}/reply", body, ok_on_404=True,
+    )
+    if resp.get("_not_found"):
+        print(f"ERROR: thread {args.thread} not found", file=sys.stderr)
+        sys.exit(1)
+
+    data = resp.get("data") or {}
+    if data.get("deduped"):
+        print(f"dedup: founder/agent message sent {int(data.get('age_s', 0))}s ago, skipping")
+        return
+
+    msg_id = data.get("message_id")
+    visitor_email = data.get("visitor_email") or ""
+    project_name = data.get("project_name")
+
+    # 4. Forward to visitor email so they get the reply when widget is closed.
+    visitor_resend_id = None
+    if not args.no_email and visitor_email:
+        cfg = project_config(project_name)
+        visitor_resend_id = email_visitor(visitor_email, project_name, args.text, cfg)
+        if visitor_resend_id and msg_id:
+            api_patch(
+                f"/api/v1/web-chat/messages/{msg_id}",
+                {"visitor_email_id": visitor_resend_id},
+            )
+
+    print(f"sent reply (msg #{msg_id}, visitor_email_id={visitor_resend_id or '-'})")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/sentry_init.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Best-effort Sentry init for the social-autoposter Python posting pipeline.
+
+Imported once from scripts/http_api.py (the central HTTP-lane client, pulled in
+by ~100 pipeline scripts), so any pipeline process that talks to the s4l.ai API
+gets Sentry error capture. Mirrors the Node .mcpb telemetry (mcp/src/telemetry.ts)
+and the Fazm app. Sentry org: `mediar-n5`.
+
+HARD RULE: this must NEVER raise into the caller. If sentry-sdk is missing or
+the DSN is unset, init() is a silent no-op so the pipeline runs unchanged.
+"""
+from __future__ import annotations
+
+import os
+
+# Client-side DSN: safe to embed, same posture as the Node telemetry and Fazm's
+# hardcoded Swift DSN. Overridable via env for dev. Empty -> Sentry disabled.
+_EMBEDDED_DSN = "https://4d44ac907262c6545cf8681703528d04@o4507617161314304.ingest.us.sentry.io/4511598804336640"
+
+_initialized = False
+
+
+def init() -> None:
+    """Initialize Sentry once per process. Idempotent and exception-safe."""
+    global _initialized
+    if _initialized:
+        return
+    # Set early so a failure below never re-attempts on every http_api import.
+    _initialized = True
+
+    dsn = os.environ.get("S4L_SENTRY_DSN") or _EMBEDDED_DSN
+    if not dsn:
+        return
+    try:
+        import sentry_sdk
+    except Exception:
+        return  # sentry-sdk not installed in this runtime; stay silent
+    try:
+        env = "development" if os.environ.get("S4L_ENV") == "development" else "production"
+        sentry_sdk.init(
+            dsn=dsn,
+            environment=env,
+            release=os.environ.get("S4L_VERSION") or None,
+            traces_sample_rate=0.0,  # errors only, no performance tracing
+            send_default_pii=False,
+        )
+        _tag_install(sentry_sdk)
+    except Exception:
+        return
+
+
+def _tag_install(sentry_sdk) -> None:
+    """Attach the stable install_id so events are attributable + cross-ref the
+    install-lane digest. Best-effort; identity.py is standalone (no http_api
+    import) so there is no import cycle."""
+    try:
+        from identity import get_identity
+
+        ident = get_identity() or {}
+        iid = ident.get("install_id")
+        host = ident.get("hostname")
+        if iid:
+            sentry_sdk.set_tag("install_id", str(iid))
+        if host:
+            sentry_sdk.set_tag("hostname", str(host))
+    except Exception:
+        pass
+
+
+def capture_exception(err, tags=None) -> None:
+    """Explicitly report an exception to Sentry with optional tags. Safe to call
+    even if init() was never run or sentry-sdk is missing (silent no-op). Use for
+    swallowed/handled errors that would otherwise never reach Sentry (the global
+    excepthook only catches UNHANDLED ones)."""
+    if not _initialized:
+        return
+    try:
+        import sentry_sdk
+    except Exception:
+        return
+    try:
+        if tags:
+            with sentry_sdk.push_scope() as scope:
+                for k, v in tags.items():
+                    scope.set_tag(str(k), str(v))
+                sentry_sdk.capture_exception(err)
+        else:
+            sentry_sdk.capture_exception(err)
+    except Exception:
+        return
+
+
+def capture_message(message, level="error", tags=None) -> None:
+    """Report a handled, non-exception condition to Sentry (e.g. a post that
+    failed gracefully and returned a reason instead of raising). The global
+    excepthook only catches UNHANDLED exceptions, so operational failures that
+    are caught + reported as a result count would otherwise never reach Sentry.
+    Safe to call even if init() never ran or sentry-sdk is missing (no-op)."""
+    if not _initialized:
+        return
+    try:
+        import sentry_sdk
+    except Exception:
+        return
+    try:
+        if tags:
+            with sentry_sdk.push_scope() as scope:
+                for k, v in tags.items():
+                    scope.set_tag(str(k), str(v))
+                sentry_sdk.capture_message(str(message), level=level)
+        else:
+            sentry_sdk.capture_message(str(message), level=level)
+    except Exception:
+        return
+
+
+def flush(timeout: float = 2.0) -> None:
+    """Block until queued events are sent (best-effort). Call before a short-lived
+    or about-to-crash process exits so a just-captured event isn't dropped on
+    teardown."""
+    if not _initialized:
+        return
+    try:
+        import sentry_sdk
+
+        sentry_sdk.flush(timeout)
+    except Exception:
+        return