nexo-brain 7.28.0 → 7.29.0

package/src/db/_schema.py

@@ -2758,6 +2758,23 @@ def _m76_semantic_layers(conn):
     _migrate_add_index(conn, "idx_semantic_layer_sources_kind", "semantic_layer_source_refs", "source_kind, validation_status")
 
 
+def _m77_morning_briefing_presentation(conn):
+    """Persist sanitized briefing bodies and Desktop read-state."""
+    _m58_morning_briefing_runs(conn)
+    _migrate_add_column(conn, "morning_briefing_runs", "body_text", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "morning_briefing_runs", "body_html", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "morning_briefing_runs", "artifact_json", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "morning_briefing_runs", "desktop_shown_at", "TEXT DEFAULT NULL")
+    _migrate_add_column(conn, "morning_briefing_runs", "desktop_opened_at", "TEXT DEFAULT NULL")
+    _migrate_add_column(conn, "morning_briefing_runs", "desktop_dismissed_at", "TEXT DEFAULT NULL")
+    _migrate_add_index(
+        conn,
+        "idx_morning_briefing_runs_desktop",
+        "morning_briefing_runs",
+        "status, desktop_shown_at, finished_at",
+    )
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -2835,6 +2852,7 @@ MIGRATIONS = [
     (74, "entity_live_profiles", _m74_entity_live_profiles),
     (75, "failure_prevention_ledger", _m75_failure_prevention_ledger),
     (76, "semantic_layers", _m76_semantic_layers),
+    (77, "morning_briefing_presentation", _m77_morning_briefing_presentation),
 ]
 
 

package/src/email_presentation.py

@@ -0,0 +1,243 @@
+"""Shared email presentation helpers for operator-facing automations.
+
+Agents may produce HTML, but SMTP, artifacts, and Desktop must only consume
+normalized/sanitized output from this module.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from dataclasses import dataclass
+from html.parser import HTMLParser
+from typing import Any
+from urllib.parse import urlparse
+
+
+ALLOWED_TAGS = {
+    "a", "b", "blockquote", "br", "code", "div", "em", "h1", "h2", "h3",
+    "hr", "i", "li", "ol", "p", "pre", "span", "strong", "table", "tbody",
+    "td", "th", "thead", "tr", "u", "ul",
+}
+VOID_TAGS = {"br", "hr"}
+ALLOWED_ATTRS = {
+    "a": {"href", "title"},
+    "td": {"colspan", "rowspan"},
+    "th": {"colspan", "rowspan"},
+}
+SAFE_URL_SCHEMES = {"http", "https", "mailto"}
+
+
+@dataclass(frozen=True)
+class EmailPresentation:
+    subject: str
+    body_text: str
+    body_html: str
+    input_format: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "subject": self.subject,
+            "body_text": self.body_text,
+            "body_html": self.body_html,
+            "input_format": self.input_format,
+        }
+
+
+class _SafeHtmlParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        clean_tag = tag.lower()
+        if clean_tag in {"script", "style", "iframe", "object", "embed", "svg", "math"}:
+            self._skip_depth += 1
+            return
+        if self._skip_depth or clean_tag not in ALLOWED_TAGS:
+            return
+        attr_bits: list[str] = []
+        allowed = ALLOWED_ATTRS.get(clean_tag, set())
+        for raw_name, raw_value in attrs:
+            name = str(raw_name or "").lower().strip()
+            if not name or name.startswith("on") or name not in allowed:
+                continue
+            value = str(raw_value or "").strip()
+            if name == "href" and not _safe_href(value):
+                continue
+            if name in {"colspan", "rowspan"}:
+                value = str(max(1, min(12, _safe_int(value, 1))))
+            attr_bits.append(f'{name}="{html.escape(value, quote=True)}"')
+        suffix = (" " + " ".join(attr_bits)) if attr_bits else ""
+        self.parts.append(f"<{clean_tag}{suffix}>")
+
+    def handle_endtag(self, tag: str) -> None:
+        clean_tag = tag.lower()
+        if clean_tag in {"script", "style", "iframe", "object", "embed", "svg", "math"}:
+            if self._skip_depth:
+                self._skip_depth -= 1
+            return
+        if self._skip_depth or clean_tag not in ALLOWED_TAGS or clean_tag in VOID_TAGS:
+            return
+        self.parts.append(f"</{clean_tag}>")
+
+    def handle_data(self, data: str) -> None:
+        if not self._skip_depth:
+            self.parts.append(html.escape(data, quote=False))
+
+    def handle_entityref(self, name: str) -> None:
+        if not self._skip_depth:
+            self.parts.append(f"&{name};")
+
+    def handle_charref(self, name: str) -> None:
+        if not self._skip_depth:
+            self.parts.append(f"&#{name};")
+
+
+def _safe_int(value: Any, fallback: int) -> int:
+    try:
+        return int(value)
+    except Exception:
+        return fallback
+
+
+def _safe_href(value: str) -> bool:
+    parsed = urlparse(value)
+    if parsed.scheme and parsed.scheme.lower() not in SAFE_URL_SCHEMES:
+        return False
+    if not parsed.scheme and value.strip().lower().startswith("javascript:"):
+        return False
+    return True
+
+
+def sanitize_html_fragment(raw_html: str) -> str:
+    parser = _SafeHtmlParser()
+    try:
+        parser.feed(str(raw_html or ""))
+        parser.close()
+    except Exception:
+        return ""
+    cleaned = "".join(parser.parts)
+    cleaned = re.sub(r"\s+javascript\s*:", "", cleaned, flags=re.I)
+    return cleaned.strip()
+
+
+def text_to_html_fragment(text: str) -> str:
+    paragraphs = re.split(r"\n{2,}", str(text or "").strip())
+    rendered: list[str] = []
+    for paragraph in paragraphs:
+        clean = html.escape(paragraph.strip(), quote=False)
+        if not clean:
+            continue
+        rendered.append(f"<p>{clean.replace(chr(10), '<br>')}</p>")
+    return "".join(rendered) or "<p></p>"
+
+
+def html_to_text(raw_html: str) -> str:
+    text = re.sub(r"(?is)<(script|style|iframe|object|embed|svg|math).*?</\1>", " ", str(raw_html or ""))
+    text = re.sub(r"(?i)<br\s*/?>", "\n", text)
+    text = re.sub(r"(?i)</(p|div|li|h1|h2|h3|tr)>", "\n", text)
+    text = re.sub(r"<[^>]+>", " ", text)
+    text = html.unescape(text)
+    lines = [" ".join(line.split()) for line in text.splitlines()]
+    return "\n".join(line for line in lines if line).strip()
+
+
+def compose_html_document(fragment: str) -> str:
+    safe_fragment = sanitize_html_fragment(fragment)
+    return (
+        '<!DOCTYPE html><html><head><meta charset="utf-8"></head>'
+        '<body style="font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,sans-serif;'
+        'font-size:14px;color:#222;line-height:1.6;">'
+        f"{safe_fragment}</body></html>"
+    )
+
+
+def signature_from_config(config: dict | None, *, fallback: str = "") -> str:
+    metadata = (config or {}).get("metadata")
+    if not isinstance(metadata, dict):
+        account = (config or {}).get("agent_account")
+        if isinstance(account, dict):
+            metadata = account.get("metadata")
+    if not isinstance(metadata, dict):
+        metadata = {}
+    signature = str(metadata.get("signature") or "").strip()
+    return signature or str(fallback or "").strip()
+
+
+def append_signature_text(body_text: str, signature: str) -> str:
+    clean_body = str(body_text or "").strip()
+    clean_signature = str(signature or "").strip()
+    if not clean_signature:
+        return clean_body
+    if clean_signature in clean_body[-500:]:
+        return clean_body
+    return f"{clean_body}\n\n-- \n{clean_signature}".strip()
+
+
+def append_signature_html(fragment: str, signature: str) -> str:
+    clean_signature = str(signature or "").strip()
+    if not clean_signature:
+        return fragment
+    safe_signature = text_to_html_fragment(clean_signature)
+    return (
+        f"{fragment}"
+        '<hr style="border:none;border-top:1px solid #ddd;margin:20px 0;">'
+        f'<div style="color:#666;font-size:12px;">{safe_signature}</div>'
+    )
+
+
+def build_email_presentation(
+    *,
+    subject: str,
+    body_text: str = "",
+    body_html: str = "",
+    signature: str = "",
+    include_signature: bool = False,
+) -> EmailPresentation:
+    clean_subject = " ".join(str(subject or "").split()).strip()
+    raw_text = str(body_text or "").strip()
+    raw_html = str(body_html or "").strip()
+    input_format = "html" if raw_html else "text"
+    text = raw_text or html_to_text(raw_html)
+    html_fragment = sanitize_html_fragment(raw_html) if raw_html else text_to_html_fragment(text)
+    if include_signature:
+        text = append_signature_text(text, signature)
+        html_fragment = append_signature_html(html_fragment, signature)
+    return EmailPresentation(
+        subject=clean_subject,
+        body_text=text,
+        body_html=compose_html_document(html_fragment),
+        input_format=input_format,
+    )
+
+
+def normalize_agent_email_payload(payload: dict[str, Any], *, signature: str = "") -> EmailPresentation:
+    subject = str(payload.get("subject") or "").strip()
+    body_text = str(payload.get("body_text") or payload.get("body") or "").strip()
+    body_html = str(payload.get("body_html") or "").strip()
+    presentation = build_email_presentation(
+        subject=subject,
+        body_text=body_text,
+        body_html=body_html,
+        signature=signature,
+        include_signature=bool(signature),
+    )
+    if not presentation.subject or not presentation.body_text:
+        raise RuntimeError("Email payload is missing subject/body_text.")
+    return presentation
+
+
+__all__ = [
+    "EmailPresentation",
+    "append_signature_html",
+    "append_signature_text",
+    "build_email_presentation",
+    "compose_html_document",
+    "html_to_text",
+    "normalize_agent_email_payload",
+    "sanitize_html_fragment",
+    "signature_from_config",
+    "text_to_html_fragment",
+]

package/src/morning_briefing.py

@@ -0,0 +1,281 @@
+"""Morning briefing persistence and Desktop-facing accessors."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import db as nexo_db
+from paths import operations_dir
+
+
+LATEST_MARKDOWN_FILE = operations_dir() / "morning-briefing-latest.md"
+LATEST_HTML_FILE = operations_dir() / "morning-briefing-latest.html"
+LATEST_JSON_FILE = operations_dir() / "morning-briefing-latest.json"
+
+PRESENTATION_COLUMNS = {
+    "body_text": "TEXT DEFAULT ''",
+    "body_html": "TEXT DEFAULT ''",
+    "artifact_json": "TEXT DEFAULT ''",
+    "desktop_shown_at": "TEXT DEFAULT NULL",
+    "desktop_opened_at": "TEXT DEFAULT NULL",
+    "desktop_dismissed_at": "TEXT DEFAULT NULL",
+}
+
+
+def _now() -> str:
+    return datetime.now().astimezone().isoformat()
+
+
+def _conn():
+    nexo_db.init_db()
+    return nexo_db.get_db()
+
+
+def ensure_morning_briefing_runs_table(conn=None) -> None:
+    conn = conn or _conn()
+    conn.execute(
+        """CREATE TABLE IF NOT EXISTS morning_briefing_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            local_date TEXT NOT NULL,
+            recipient TEXT NOT NULL,
+            status TEXT NOT NULL DEFAULT 'in_progress',
+            subject TEXT DEFAULT '',
+            body_text TEXT DEFAULT '',
+            body_html TEXT DEFAULT '',
+            artifact_json TEXT DEFAULT '',
+            send_output TEXT DEFAULT '',
+            error TEXT DEFAULT '',
+            desktop_shown_at TEXT DEFAULT NULL,
+            desktop_opened_at TEXT DEFAULT NULL,
+            desktop_dismissed_at TEXT DEFAULT NULL,
+            started_at TEXT DEFAULT (datetime('now')),
+            finished_at TEXT DEFAULT NULL,
+            updated_at TEXT DEFAULT (datetime('now')),
+            UNIQUE(local_date, recipient)
+        )"""
+    )
+    existing = {
+        str(row[1])
+        for row in conn.execute("PRAGMA table_info(morning_briefing_runs)").fetchall()
+    }
+    for name, ddl in PRESENTATION_COLUMNS.items():
+        if name not in existing:
+            conn.execute(f"ALTER TABLE morning_briefing_runs ADD COLUMN {name} {ddl}")
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_morning_briefing_runs_date "
+        "ON morning_briefing_runs(local_date)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_morning_briefing_runs_status "
+        "ON morning_briefing_runs(status)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_morning_briefing_runs_desktop "
+        "ON morning_briefing_runs(status, desktop_shown_at, finished_at)"
+    )
+
+
+def _row_to_dict(row) -> dict[str, Any]:
+    if row is None:
+        return {}
+    try:
+        return dict(row)
+    except Exception:
+        return {}
+
+
+def _artifact_paths() -> dict[str, str]:
+    return {
+        "markdown": str(LATEST_MARKDOWN_FILE),
+        "html": str(LATEST_HTML_FILE),
+        "json": str(LATEST_JSON_FILE),
+    }
+
+
+def write_latest_briefing_artifacts(
+    *,
+    recipient: str,
+    subject: str,
+    body_text: str,
+    body_html: str,
+    local_date: str = "",
+    run_id: int | None = None,
+) -> dict[str, Any]:
+    generated_at = _now()
+    LATEST_MARKDOWN_FILE.parent.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "schema": "nexo.morning_briefing.v1",
+        "generated_at": generated_at,
+        "local_date": local_date,
+        "run_id": run_id,
+        "recipient": recipient,
+        "subject": subject,
+        "body_text": body_text,
+        "body_html": body_html,
+        "artifacts": _artifact_paths(),
+    }
+    markdown = (
+        "# Morning briefing\n\n"
+        f"- Generated at: {generated_at}\n"
+        f"- To: {recipient}\n"
+        f"- Subject: {subject}\n\n"
+        f"{body_text}\n"
+    )
+    LATEST_MARKDOWN_FILE.write_text(markdown, encoding="utf-8")
+    LATEST_HTML_FILE.write_text(body_html, encoding="utf-8")
+    LATEST_JSON_FILE.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    return payload
+
+
+def mark_morning_briefing_sent(
+    *,
+    local_date: str,
+    recipient: str,
+    subject: str,
+    body_text: str,
+    body_html: str,
+    send_output: str = "",
+    artifact_payload: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    conn = _conn()
+    ensure_morning_briefing_runs_table(conn)
+    now = _now()
+    artifact_json = json.dumps(artifact_payload or {}, ensure_ascii=False)
+    conn.execute(
+        """
+        UPDATE morning_briefing_runs
+        SET status = 'sent',
+            subject = ?,
+            body_text = ?,
+            body_html = ?,
+            artifact_json = ?,
+            send_output = ?,
+            error = '',
+            finished_at = ?,
+            updated_at = ?
+        WHERE local_date = ? AND recipient = ?
+        """,
+        (
+            str(subject or ""),
+            str(body_text or ""),
+            str(body_html or ""),
+            artifact_json,
+            str(send_output or ""),
+            now,
+            now,
+            str(local_date or ""),
+            str(recipient or ""),
+        ),
+    )
+    conn.commit()
+    return latest_morning_briefing()
+
+
+def latest_morning_briefing(*, include_non_sent: bool = False) -> dict[str, Any]:
+    conn = _conn()
+    ensure_morning_briefing_runs_table(conn)
+    if include_non_sent:
+        row = conn.execute(
+            """
+            SELECT * FROM morning_briefing_runs
+            ORDER BY COALESCE(finished_at, updated_at, started_at) DESC, id DESC
+            LIMIT 1
+            """
+        ).fetchone()
+    else:
+        row = conn.execute(
+            """
+            SELECT * FROM morning_briefing_runs
+            WHERE status = 'sent'
+            ORDER BY COALESCE(finished_at, updated_at, started_at) DESC, id DESC
+            LIMIT 1
+            """
+        ).fetchone()
+    payload = public_briefing_payload(_row_to_dict(row))
+    return {"ok": True, "briefing": payload}
+
+
+def public_briefing_payload(row: dict[str, Any]) -> dict[str, Any] | None:
+    if not row:
+        return None
+    artifact_payload: dict[str, Any] = {}
+    try:
+        parsed = json.loads(row.get("artifact_json") or "{}")
+        if isinstance(parsed, dict):
+            artifact_payload = parsed
+    except Exception:
+        artifact_payload = {}
+    return {
+        "id": row.get("id"),
+        "local_date": row.get("local_date") or "",
+        "recipient": row.get("recipient") or "",
+        "status": row.get("status") or "",
+        "subject": row.get("subject") or "",
+        "body_text": row.get("body_text") or "",
+        "body_html": row.get("body_html") or "",
+        "send_output": row.get("send_output") or "",
+        "error": row.get("error") or "",
+        "started_at": row.get("started_at") or "",
+        "finished_at": row.get("finished_at") or "",
+        "updated_at": row.get("updated_at") or "",
+        "desktop_shown_at": row.get("desktop_shown_at") or "",
+        "desktop_opened_at": row.get("desktop_opened_at") or "",
+        "desktop_dismissed_at": row.get("desktop_dismissed_at") or "",
+        "unseen": not bool(row.get("desktop_shown_at")),
+        "artifacts": artifact_payload.get("artifacts") or _artifact_paths(),
+        "schema": "nexo.morning_briefing.v1",
+    }
+
+
+def mark_desktop_state(action: str, *, briefing_id: int | None = None) -> dict[str, Any]:
+    field_by_action = {
+        "shown": "desktop_shown_at",
+        "opened": "desktop_opened_at",
+        "dismissed": "desktop_dismissed_at",
+    }
+    field = field_by_action.get(str(action or "").strip().lower())
+    if not field:
+        return {"ok": False, "error": f"Unknown briefing mark action: {action}"}
+    conn = _conn()
+    ensure_morning_briefing_runs_table(conn)
+    if briefing_id:
+        row = _row_to_dict(conn.execute(
+            "SELECT * FROM morning_briefing_runs WHERE id = ? LIMIT 1",
+            (int(briefing_id),),
+        ).fetchone())
+    else:
+        row = (latest_morning_briefing().get("briefing") or {})
+        if row:
+            row = _row_to_dict(conn.execute(
+                "SELECT * FROM morning_briefing_runs WHERE id = ? LIMIT 1",
+                (int(row.get("id") or 0),),
+            ).fetchone())
+    if not row:
+        return {"ok": False, "error": "No morning briefing found."}
+    now = _now()
+    conn.execute(
+        f"UPDATE morning_briefing_runs SET {field} = ?, updated_at = ? WHERE id = ?",
+        (now, now, int(row.get("id"))),
+    )
+    conn.commit()
+    updated = _row_to_dict(conn.execute(
+        "SELECT * FROM morning_briefing_runs WHERE id = ? LIMIT 1",
+        (int(row.get("id")),),
+    ).fetchone())
+    return {"ok": True, "briefing": public_briefing_payload(updated), "marked": action}
+
+
+__all__ = [
+    "LATEST_HTML_FILE",
+    "LATEST_JSON_FILE",
+    "LATEST_MARKDOWN_FILE",
+    "ensure_morning_briefing_runs_table",
+    "latest_morning_briefing",
+    "mark_desktop_state",
+    "mark_morning_briefing_sent",
+    "public_briefing_payload",
+    "write_latest_briefing_artifacts",
+]

package/src/script_registry.py

@@ -935,6 +935,7 @@ def list_scripts(include_core: bool = False) -> list[dict]:
             or bool(contract.get("toggleable_core"))
         )
         entry["supports_extra_instructions"] = bool(contract.get("supports_extra_instructions"))
+        entry["supports_automation_preferences"] = bool(contract.get("supports_automation_preferences"))
         entry["operator_extra_instructions"] = str(metadata.get("operator_extra_instructions") or "")
         entry["runtime_contract"] = contract
         entry["available"] = bool(contract.get("available", True))
@@ -2930,6 +2931,20 @@ def set_automation_instructions(name_or_path: str, instructions: str) -> dict:
     return set_script_extra_instructions(name_or_path, instructions)
 
 
+def get_automation_preference_contract(name_or_path: str) -> dict:
+    """Return schema + current structured preferences for a product automation."""
+    from automation_preferences import get_automation_preferences
+
+    return get_automation_preferences(name_or_path)
+
+
+def set_automation_preference_contract(name_or_path: str, payload: dict) -> dict:
+    """Persist structured preferences without touching extra instructions."""
+    from automation_preferences import set_automation_preferences
+
+    return set_automation_preferences(name_or_path, payload)
+
+
 def set_script_schedule_override(
     name_or_path: str,
     *,