Have it reach you

"""Watch the harness's own mailbox and answer whoever writes to it.

Polls the agent address with tools.email, hands every new message to the
Butler agent — which replies from the same address — and appends both the
message and the answer to /home/daytona/mailbutler.log. State survives a
restart in /home/daytona/.mailbutler.json; a lockfile makes starting it
twice harmless.

Start it the ordinary way:

    setsid nohup python3 ~/harness/programs/mailbutler/main.py \
        > /tmp/mailbutler.log 2>&1 &
"""
from __future__ import annotations

import datetime as dt
import fcntl
import hashlib
import json
import sys
import time
import traceback
from pathlib import Path

sys.path.insert(0, "/home/daytona")  # tools.email lives there

from splox import agent
from tools.agents import schema
from tools.email import email_address, email_inbox, email_send

HERE = Path(__file__).parent
STATE = Path("/home/daytona/.mailbutler.json")
LOG = Path("/home/daytona/mailbutler.log")
LOCK = Path("/tmp/mailbutler.lock")
POLL_SECONDS = 20

Reply = schema(reply=str, summary=str)


def prompt():
    """The prompt as it is now — an edit lands on the next message."""
    return (HERE / "prompts" / "butler.md").read_text(encoding="utf-8")


butler = agent(
    "Butler",
    system_prompt=prompt,
    model="kimi-k3",
    provider="splox",
    tools=["system:compute"],
    max_iterations=25,
)

# Senders a reply can only bounce off of.
SKIP_LOCALPARTS = {"mailer-daemon", "postmaster", "no-reply", "noreply", "bounce"}


def skip_reason(sender: str, me: str) -> str | None:
    sender = (sender or "").strip().lower()
    if not sender:
        return "no sender"
    if sender == me.lower():
        return "own outgoing mail"
    if sender.split("@", 1)[0] in SKIP_LOCALPARTS:
        return "bounce/no-reply address"
    return None


def handle(msg, me: str) -> None:
    """Reply to one message and write the exchange to the log."""
    sender = (msg.get("sender") or "").strip()
    subject = (msg.get("subject") or "").strip() or "(no subject)"
    body = str(msg.get("body", ""))

    ask = (
        f"A new email has arrived at {me}.\n\n"
        f"Sender: {sender}\nSubject: {subject}\n\n"
        f"Message:\n{body[:8000]}\n\n"
        "Reply to it now, following your instructions."
    )
    try:
        out = butler(ask, schema=Reply, wait=True).output()
        reply_text, summary = out["reply"], out["summary"]
    except Exception as failure:  # the correspondent must never be left hanging
        traceback.print_exc()
        reply_text = (
            "Thank you for your email — it reached me, but I could not compose "
            "a proper reply just now. I'll come back to you."
        )
        summary = f"butler run failed ({failure}); sent holding reply instead"

    email_send(to=[sender], subject=reply_subject(subject), text=reply_text)
    log(f"--- reply sent to {sender} " + "-" * 40)
    log(reply_text)
    log(summary)


def poll(me: str, state: dict) -> None:
    inbox = email_inbox(limit=100, since=state.get("since"))
    fresh = [m for m in inbox.get("messages", []) if key_of(m) not in set(state["seen"])]
    fresh.sort(key=lambda m: str(m.get("timestamp") or ""))   # oldest first
    for msg in fresh:
        state["seen"].append(key_of(msg))
        state["since"] = str(msg.get("timestamp") or state.get("since") or "")
        why = skip_reason(msg.get("sender"), me)
        if why:
            log(f"{utcnow()} UTC  skipped {msg.get('sender')!r}: {why}")
            continue
        handle(msg, me)
    save_state(state)


def main() -> None:
    holder = LOCK.open("w")
    try:
        fcntl.flock(holder, fcntl.LOCK_EX | fcntl.LOCK_NB)
    except BlockingIOError:
        print("another mail butler already holds the lock; exiting", flush=True)
        return

    me = email_address()["address"]
    state = load_state()
    log(f"{utcnow()} UTC  mail butler watching {me} (since {state.get('since')})")
    while True:
        try:
            poll(me, state)
        except Exception:
            traceback.print_exc()
            log(f"{utcnow()} UTC  poll failed; sleeping and retrying")
        time.sleep(POLL_SECONDS)


if __name__ == "__main__":
    main()