@cohortapp/agent-sdk 2.3.0

package/scripts/send-email-threaded.py

@@ -0,0 +1,392 @@
+#!/usr/bin/env python3
+"""Send a properly threaded HTML email reply via Gmail SMTP.
+
+Usage: python3 send-email-threaded.py <to> <subject> <body> [--reply-to-subject "original subject"] [--attachment file] [--force]
+
+If --reply-to-subject is provided, fetches the real Message-IDs from the
+thread via IMAP and includes them in In-Reply-To/References for proper Gmail threading.
+
+If --attachment is provided, attaches the specified file (can be repeated for multiple files).
+
+If --force is provided, bypasses dedup checks (use only for exceptional cases).
+
+Pre-send dedup layers:
+  1. LLM-based dedup (llm_email_dedup.py) — reads recent conversation history with
+     recipient, asks Claude Haiku if the topic has already been addressed.
+     Replaces the old subject+recipient lock per CEO directive ib-20260406-001.
+  2. Gmail Sent folder check (IMAP) — double-check against actual sent mail
+  3. Content-hash dedup (outbound_dedup.py) — catch identical concurrent sends
+"""
+import sys
+import os
+import imaplib
+import email
+import smtplib
+import mimetypes
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from email.mime.base import MIMEBase
+from email import encoders
+from email.utils import formatdate
+
+# LLM-based dedup (Layer 1) — replaces old subject+recipient lock per CEO directive ib-20260406-001
+try:
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from llm_email_dedup import llm_dedup_check
+    _LLM_DEDUP_AVAILABLE = True
+except ImportError:
+    _LLM_DEDUP_AVAILABLE = False
+
+# Content-hash dedup (Layer 3) — fail-open if module not available
+try:
+    from outbound_dedup import acquire_email_lock, confirm_email_lock
+    _DEDUP_AVAILABLE = True
+except ImportError:
+    _DEDUP_AVAILABLE = False
+
+# Pre-send factual validation (Layer 0 — runs before all dedup) — fail-open
+try:
+    from validate_outbound import validate_message, log_validation_result
+    _VALIDATION_AVAILABLE = True
+except ImportError:
+    _VALIDATION_AVAILABLE = False
+
+# Thread quoting — include original email chain in replies — fail-open
+try:
+    from email_quote_thread import fetch_thread_body, format_quoted_html
+    _QUOTE_AVAILABLE = True
+except ImportError:
+    _QUOTE_AVAILABLE = False
+
+# Pre-draft context enrichment (Phase 7) — advisory, never blocks — fail-open
+try:
+    from pre_draft_lookup import pre_draft_lookup
+    _PRE_DRAFT_AVAILABLE = True
+except ImportError:
+    _PRE_DRAFT_AVAILABLE = False
+
+# ── Agent identity from config/agent.json (canonical SOT) ──────────────
+# Loaded once at module load so every call picks up the running agent's
+# email, full name, title, and phone without hardcoded values.
+import json
+from pathlib import Path
+_AGENT_REPO_DIR = Path(os.environ.get("AGENT_DIR", str(Path(__file__).resolve().parent.parent)))
+try:
+    _AGENT = json.loads((_AGENT_REPO_DIR / "config" / "agent.json").read_text())
+except Exception:
+    _AGENT = {"firstName": "Agent", "fullName": "Agent", "email": "agent@example.com", "title": "Agent", "phone": ""}
+
+USER = _AGENT.get("email", "agent@example.com")
+PASSWORD = os.environ.get("GMAIL_APP_PASSWORD", "")
+LOGO_URL = os.environ.get(
+    "EMAIL_SIGNATURE_LOGO_URL",
+    "https://ci3.googleusercontent.com/mail-sig/AIorK4xNDnPN6a0MjSHV5urb9g11u2CzHIzwdJbwN21quGjzQFdbOdegCq1Wp6lq3NCqsARbi-ooqPfE9E1D",
+)
+
+def _is_external(recipient: str) -> bool:
+    """True if `recipient` is outside the agent's own email domain.
+
+    Used to fail Layer-0 validation CLOSED for outbound mail leaving the org
+    while keeping internal automation fail-open (Phase 0 item 0.5). Anything we
+    cannot confidently classify as internal is treated as external (safe
+    default): no '@', a different domain, or an unparseable address all return
+    True.
+    """
+    try:
+        addr = (recipient or "").strip().lower()
+        if "@" not in addr:
+            return True
+        recipient_domain = addr.rsplit("@", 1)[1]
+        own = (USER or "").strip().lower()
+        own_domain = own.rsplit("@", 1)[1] if "@" in own else ""
+        if not own_domain:
+            return True  # cannot establish our own domain → treat as external
+        return recipient_domain != own_domain
+    except Exception:
+        return True
+
+
+def get_thread_message_ids(subject_search):
+    """Fetch real Message-IDs from Gmail via IMAP for threading."""
+    mail = imaplib.IMAP4_SSL("imap.gmail.com")
+    mail.login(USER, PASSWORD)
+    mail.select("INBOX")
+
+    # Search by subject — normalize non-ASCII chars for IMAP compatibility
+    clean_subject = subject_search.replace("Re: ", "").replace("RE: ", "").strip()
+    # Replace common non-ASCII characters that break IMAP search
+    ascii_subject = clean_subject.replace('\u2014', '-').replace('\u2013', '-').replace('\u2018', "'").replace('\u2019', "'").replace('\u201c', '"').replace('\u201d', '"')
+    status, messages = mail.search(None, f'(SUBJECT "{ascii_subject}")')
+    msg_ids = []
+    if status == "OK" and messages[0]:
+        for num in messages[0].split():
+            status, data = mail.fetch(num, '(RFC822.HEADER)')
+            if status == "OK":
+                hdr = email.message_from_string(data[0][1].decode('utf-8', errors='replace'))
+                mid = hdr.get('Message-ID', '')
+                if mid:
+                    msg_ids.append(mid)
+    mail.logout()
+    return msg_ids
+
+def mark_as_read(sender):
+    """Mark emails from sender as read."""
+    mail = imaplib.IMAP4_SSL("imap.gmail.com")
+    mail.login(USER, PASSWORD)
+    mail.select("INBOX")
+    status, messages = mail.search(None, f'(UNSEEN FROM "{sender}")')
+    if status == "OK" and messages[0]:
+        for num in messages[0].split():
+            mail.store(num, '+FLAGS', '\\Seen')
+    mail.logout()
+
+def build_signature_html():
+    full_name = _AGENT.get("fullName", "Agent")
+    title = _AGENT.get("title", "")
+    phone = _AGENT.get("phone", "")
+    phone_line = f'<div style="font-size:x-small;color:#000;">{phone}</div>\n<div><br></div>\n' if phone else ""
+    address = os.environ.get(
+        "EMAIL_SIGNATURE_ADDRESS",
+        "Level 1, Innovation One, Dubai International Financial Centre, Dubai, UAE",
+    )
+    return f"""<div>
+<div style="font-size:small;"><b>{full_name}</b></div>
+<div style="font-size:small;">{title}</div>
+<div><br></div>
+<div><img src="{LOGO_URL}" width="125"></div>
+<div><br></div>
+{phone_line}<div style="font-size:x-small;color:#000;">{address}</div>
+<div style="font-size:x-small;color:#666;">_________________________________________</div>
+<div style="font-size:x-small;color:#999;">This email and any files transmitted with it are confidential and intended solely for the use of the individual or entity to whom they are addressed. If you have received this email in error please notify the sender. This message contains confidential information and is intended only for the individual named. If you are not the named addressee you should not disseminate, distribute or copy this email. Please notify the sender immediately by email if you have received this email by mistake and delete this email from your system. If you are not the intended recipient you are notified that disclosing, copying, distributing, or taking any action in reliance on the contents of this information is strictly prohibited.</div>
+</div>"""
+
+def attach_file(msg, filepath):
+    """Attach a file to the email message."""
+    if not os.path.exists(filepath):
+        print(f"WARNING: Attachment not found: {filepath}", file=sys.stderr)
+        return False
+
+    filename = os.path.basename(filepath)
+    content_type, encoding = mimetypes.guess_type(filepath)
+    if content_type is None:
+        content_type = "application/octet-stream"
+    main_type, sub_type = content_type.split("/", 1)
+
+    with open(filepath, "rb") as f:
+        file_data = f.read()
+
+    attachment = MIMEBase(main_type, sub_type)
+    attachment.set_payload(file_data)
+    encoders.encode_base64(attachment)
+    attachment.add_header("Content-Disposition", "attachment", filename=filename)
+    msg.attach(attachment)
+    return True
+
+
+def check_already_sent(to, subject):
+    """Check Gmail Sent Mail for a recent email to the same recipient with same subject.
+    Returns True if a matching email was sent in the last 24 hours."""
+    try:
+        mail = imaplib.IMAP4_SSL("imap.gmail.com")
+        mail.login(USER, PASSWORD)
+        mail.select('"[Gmail]/Sent Mail"')
+        # Search for emails to this recipient with this subject
+        clean_subject = subject.replace("RE: ", "").replace("Re: ", "").strip()
+        # Normalize non-ASCII characters for IMAP compatibility
+        clean_subject = clean_subject.replace('\u2014', '-').replace('\u2013', '-').replace('\u2018', "'").replace('\u2019', "'").replace('\u201c', '"').replace('\u201d', '"')
+        # Search sent mail for matching subject in last 24 hours
+        from datetime import datetime, timedelta
+        since_date = (datetime.now() - timedelta(hours=24)).strftime("%d-%b-%Y")
+        status, messages = mail.search(None, f'(SINCE "{since_date}" TO "{to}" SUBJECT "{clean_subject}")')
+        found = status == "OK" and messages[0] and len(messages[0].split()) > 0
+        count = len(messages[0].split()) if found else 0
+        mail.logout()
+        if found:
+            print(f"SENT_MAIL_DEDUP: Found {count} matching email(s) to {to} with subject containing '{clean_subject}' in last 24h", file=sys.stderr)
+        return found
+    except Exception as e:
+        print(f"SENT_MAIL_CHECK_ERROR: {e}", file=sys.stderr)
+        return False  # fail-open
+
+
+def send_email(to, subject, body, reply_subject=None, attachments=None, cc=None, force=False):
+    # ── Pre-draft context enrichment (Phase 7) ─────────────────────
+    # Look up recipient in entity index. Advisory only — never blocks sending.
+    # Logs context to logs/audit/{date}-pre-draft-lookups.jsonl
+    if _PRE_DRAFT_AVAILABLE:
+        try:
+            _ctx = pre_draft_lookup(to, message_type="email")
+            if _ctx and _ctx.get("communication", {}).get("standing_instructions"):
+                print(f"PRE_DRAFT: {len(_ctx['communication']['standing_instructions'])} standing instruction(s) for {to}", file=sys.stderr)
+        except Exception as e:
+            print(f"PRE_DRAFT_WARN (fail-open): {e}", file=sys.stderr)
+
+    # ── Layer 0: Pre-send factual validation ────────────────────────
+    # Checks relationship claims, title accuracy, AI disclosure, in-person scheduling.
+    # Blocks send if critical issues found (severity=block).
+    # Fail-CLOSED for external recipients (Phase 0 item 0.5): if the validator
+    # is unavailable or errors, an external send is refused rather than silently
+    # skipping Layer-0 compliance. Internal/forced sends remain fail-open.
+    _external = _is_external(to)
+    if body and not _VALIDATION_AVAILABLE:
+        if _external and not force:
+            print(f"BLOCKED: outbound validator unavailable — refusing external send to {to} (fail closed). Use --force to override.", file=sys.stderr)
+            return
+        print("VALIDATION_SKIP: validator unavailable (internal/forced send — fail-open)", file=sys.stderr)
+    if _VALIDATION_AVAILABLE and body:
+        try:
+            validation_result = validate_message(body, "email", to)
+            log_validation_result(validation_result)
+            if validation_result["metadata"]["blockers"] > 0:
+                print(f"VALIDATION_BLOCK: {validation_result['metadata']['blockers']} issue(s) found in message to {to}")
+                for issue in validation_result["issues"]:
+                    if issue["severity"] == "block":
+                        print(f"  [{issue['type']}] {issue['description']}")
+                        if issue.get("suggestion"):
+                            print(f"    -> {issue['suggestion']}")
+                print("Fix the above issues before sending. Use --force to override (not recommended).", file=sys.stderr)
+                if not force:
+                    return
+                else:
+                    print("FORCE_OVERRIDE: Bypassing validation block", file=sys.stderr)
+            elif validation_result["metadata"]["warnings"] > 0:
+                print(f"VALIDATION_WARN: {validation_result['metadata']['warnings']} warning(s) for message to {to}", file=sys.stderr)
+                for issue in validation_result["issues"]:
+                    if issue["severity"] == "warn":
+                        print(f"  [{issue['type']}] {issue['description']}", file=sys.stderr)
+        except Exception as e:
+            print(f"VALIDATION_ERROR: {e}", file=sys.stderr)
+            if _external and not force:
+                print(f"BLOCKED: validator error on external send to {to} (fail closed). Use --force to override.", file=sys.stderr)
+                return
+            print("VALIDATION_ERROR (fail-open: internal/forced send)", file=sys.stderr)
+
+    # ── Layer 1: LLM-based dedup ──────────────────────────────────────
+    # Reads recent conversation history with the recipient, asks Claude Haiku
+    # whether this topic has already been addressed. Replaces the old
+    # subject+recipient lock per CEO directive ib-20260406-001.
+    if _LLM_DEDUP_AVAILABLE and not force:
+        try:
+            llm_result = llm_dedup_check(to, subject, body)
+            if llm_result["skip"]:
+                print(f"DEDUP_SKIP (LLM): {llm_result['reason']} [confidence={llm_result['confidence']}, msgs_checked={llm_result['recent_messages']}]")
+                return
+            else:
+                print(f"LLM_DEDUP_OK: {llm_result['reason'][:100]} [msgs_checked={llm_result['recent_messages']}]", file=sys.stderr)
+        except Exception as e:
+            print(f"LLM_DEDUP_WARN (fail-open): {e}", file=sys.stderr)
+    elif force and _LLM_DEDUP_AVAILABLE:
+        print(f"FORCE_OVERRIDE: Bypassing LLM dedup for '{subject}' to {to}", file=sys.stderr)
+
+    # ── Layer 2: Gmail Sent folder check ─────────────────────────────
+    # Double-check against actual sent mail via IMAP
+    if not force and check_already_sent(to, subject):
+        print(f"DEDUP_SKIP (sent mail check): Already sent to {to} with subject '{subject}' in last 24h")
+        return
+
+    # ── Layer 3: Content-hash dedup ──────────────────────────────────
+    # Catches identical concurrent sends (same content hash)
+    _dedup_key = None
+    if _DEDUP_AVAILABLE and not force:
+        try:
+            _dedup_key, _dedup_result = acquire_email_lock(to, subject, body)
+            if _dedup_result == "DEDUP_SKIP":
+                print("DEDUP_SKIP (content hash)")
+                return
+        except Exception:
+            pass  # fail-open
+
+    has_attachments = attachments and len(attachments) > 0
+
+    if has_attachments:
+        msg = MIMEMultipart('mixed')
+    else:
+        msg = MIMEMultipart('alternative')
+
+    msg['From'] = f"{_AGENT.get('fullName', 'Agent')} <{USER}>"
+    msg['To'] = to
+    if cc:
+        msg['Cc'] = cc
+    msg['Subject'] = subject
+    msg['Date'] = formatdate(localtime=True)
+
+    # Add threading headers if replying
+    if reply_subject:
+        thread_ids = get_thread_message_ids(reply_subject)
+        if thread_ids:
+            msg['In-Reply-To'] = thread_ids[-1]
+            msg['References'] = ' '.join(thread_ids)
+
+    # Fetch quoted thread content for replies
+    quoted_html = ""
+    if reply_subject and _QUOTE_AVAILABLE:
+        try:
+            thread_msg = fetch_thread_body(USER, PASSWORD, reply_subject, exclude_from=USER)
+            quoted_html = format_quoted_html(thread_msg)
+        except Exception as e:
+            print(f"QUOTE_WARN: {e}", file=sys.stderr)
+
+    # Build HTML
+    body_html = body.replace('\n', '<br>')
+    html = f"""<html><body style="font-family:Arial,Helvetica,sans-serif;font-size:small;color:#000;">
+<div>{body_html}</div>
+<br>
+{build_signature_html()}
+{quoted_html}
+</body></html>"""
+
+    if has_attachments:
+        html_part = MIMEMultipart('alternative')
+        html_part.attach(MIMEText(html, 'html'))
+        msg.attach(html_part)
+        for filepath in attachments:
+            if attach_file(msg, filepath):
+                print(f"Attached: {os.path.basename(filepath)}")
+    else:
+        msg.attach(MIMEText(html, 'html'))
+
+    # Send
+    with smtplib.SMTP('smtp.gmail.com', 587) as server:
+        server.starttls()
+        server.login(USER, PASSWORD)
+        server.send_message(msg)
+
+    # Mark sender's emails as read
+    sender_domain = to.split('@')[-1] if '@' in to else ''
+    if sender_domain:
+        mark_as_read(to)
+
+    print(f"Sent to {to}, subject: {subject}")
+    if cc:
+        print(f"  CC: {cc}")
+    if has_attachments:
+        print(f"  Attachments: {len(attachments)}")
+
+    # Post-send: confirm content-hash lock (audit trail)
+    if _DEDUP_AVAILABLE:
+        try:
+            confirm_email_lock(_dedup_key, f"To:{to} Subj:{subject}", to=to, subject=subject)
+        except Exception:
+            pass
+
+if __name__ == '__main__':
+    if len(sys.argv) < 4 and '--help' not in sys.argv and '-h' not in sys.argv:
+        print("Usage: send-email-threaded.py <to> <subject> <body> [--reply-to-subject 'original subject'] [--attachment file]")
+        sys.exit(1)
+
+    import argparse
+    parser = argparse.ArgumentParser(description=f"Send threaded HTML email as {_AGENT.get('fullName', 'the agent')} via Gmail SMTP")
+    parser.add_argument("to", help="Recipient email address")
+    parser.add_argument("subject", help="Email subject line")
+    parser.add_argument("body", help="Email body text (newlines become <br> in HTML)")
+    parser.add_argument("--reply-to-subject", dest="reply_subject",
+                        help="Original subject for threading (fetches Message-IDs via IMAP)")
+    parser.add_argument("--cc", dest="cc",
+                        help="CC recipient email address(es)")
+    parser.add_argument("--attachment", action="append", dest="attachments",
+                        help="File to attach (can be specified multiple times)")
+    parser.add_argument("--force", action="store_true", default=False,
+                        help="Override thread dedup — use only for exceptional resends")
+    args = parser.parse_args()
+
+    send_email(args.to, args.subject, args.body, args.reply_subject, args.attachments, args.cc, args.force)