📡 Canais paralelos

CREATE TABLE channel_links (
    id           BIGSERIAL PRIMARY KEY,
    user_id      BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    channel      TEXT NOT NULL CHECK (channel IN ('telegram','slack','web')),
    external_id  TEXT NOT NULL,           -- tg_user_id / slack U... / cookie
    linked_at    TIMESTAMPTZ NOT NULL DEFAULT now(),
    last_seen_at TIMESTAMPTZ,
    UNIQUE (channel, external_id)         -- 1 conta externa = 1 user
);

CREATE INDEX idx_channel_links_user ON channel_links(user_id);

-- Tabela de pareamento temporário (TTL 10min)
CREATE TABLE channel_pairing_codes (
    code         CHAR(6) PRIMARY KEY,     -- "493017"
    user_id      BIGINT NOT NULL REFERENCES users(id),
    expires_at   TIMESTAMPTZ NOT NULL
);

from slack_bolt.async_app import AsyncApp
from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
from .agent import run_agent
from .channels.base import Channel
from .identity import resolve_user

class SlackChannel(Channel):
    name = "slack"

    def __init__(self, bot_token: str, app_token: str):
        self.app = AsyncApp(token=bot_token)
        self.handler = AsyncSocketModeHandler(self.app, app_token)
        self._register()

    def _register(self):
        @self.app.event("message")
        async def on_message(event, say):
            if event.get("bot_id"):           # ignora ecos do próprio bot
                return
            user = await resolve_user("slack", event["user"])
            if not user:
                await say(text="Conta não vinculada. Use /link <código> pra parear.",
                          thread_ts=event.get("ts"))
                return

            blocks = await run_agent(user_id=user.id, text=event["text"])
            await say(
                blocks=render_for(blocks, "slack"),
                thread_ts=event.get("thread_ts") or event["ts"],  # preserva contexto
                channel=event["channel"],
            )

    async def start(self):
        await self.handler.start_async()

    async def push(self, user_id: int, blocks: list, channel_id: str):
        await self.app.client.chat_postMessage(
            channel=channel_id,
            blocks=render_for(blocks, "slack"),
        )

from fastapi import FastAPI, Depends, HTTPException
from sse_starlette.sse import EventSourceResponse
from pydantic import BaseModel
import json
from .agent import stream_agent
from .identity import resolve_user_by_session

app = FastAPI()

class ChatIn(BaseModel):
    text: str
    conversation_id: str | None = None

@app.post("/chat")
async def chat(body: ChatIn, session: str = Depends(get_session_cookie)):
    user = await resolve_user_by_session(session)
    if not user:
        raise HTTPException(401, "not linked")

    async def event_stream():
        async for chunk in stream_agent(
            user_id=user.id,
            text=body.text,
            conversation_id=body.conversation_id,
        ):
            # chunk = {"type": "token"|"tool_call"|"done", "data": ...}
            yield {"event": chunk["type"], "data": json.dumps(chunk["data"])}

    return EventSourceResponse(event_stream(), ping=15)

from datetime import datetime
from zoneinfo import ZoneInfo

QUIET_START, QUIET_END = 22, 8   # 22h às 8h local

async def push(user_id: int, blocks: list, *, urgency: str = "normal"):
    user = await load_user(user_id)
    tz = ZoneInfo(user.timezone or "America/Sao_Paulo")
    hour = datetime.now(tz).hour

    in_quiet = hour >= QUIET_START or hour < QUIET_END
    if in_quiet and urgency != "critical":
        # enfileira pra primeira hora da manhã
        await queue_push(user_id, blocks, deliver_at=next_morning(tz))
        return

    # ordem de preferência configurada pelo user
    for ch_name in user.channel_preference:   # ex: ["slack","telegram","web"]
        link = await get_link(user_id, ch_name)
        if not link:
            continue
        try:
            await CHANNELS[ch_name].push(user_id, blocks, link.external_id)
            await audit(user_id, ch_name, "push_sent", urgency=urgency)
            return
        except Exception as e:
            await audit(user_id, ch_name, "push_failed", error=str(e))
            continue   # tenta próximo canal

    await audit(user_id, "none", "push_dropped", reason="all_channels_failed")

def render_for(blocks: list[dict], channel_type: str):
    """blocks = [{"type":"text","content":"..."}, {"type":"button",...}]"""

    if channel_type == "telegram":
        # MarkdownV2 — escape pesado obrigatório
        out = []
        for b in blocks:
            if b["type"] == "text":
                out.append(_escape_mdv2(b["content"]))
            elif b["type"] == "code":
                out.append(f"```\n{b['content']}\n```")
            elif b["type"] == "link":
                out.append(f"[{_escape_mdv2(b['label'])}]({b['url']})")
        return {"text": "\n".join(out), "parse_mode": "MarkdownV2"}

    elif channel_type == "slack":
        # Block Kit — JSON estruturado
        slack_blocks = []
        for b in blocks:
            if b["type"] == "text":
                slack_blocks.append({"type": "section",
                    "text": {"type": "mrkdwn", "text": b["content"]}})
            elif b["type"] == "button":
                slack_blocks.append({"type": "actions", "elements": [
                    {"type": "button",
                     "text": {"type": "plain_text", "text": b["label"]},
                     "action_id": b["action_id"],
                     "value": b.get("value", "")}
                ]})
            elif b["type"] == "code":
                slack_blocks.append({"type": "section",
                    "text": {"type": "mrkdwn", "text": f"```{b['content']}```"}})
        return slack_blocks

    elif channel_type == "web":
        # HTML sanitizado (bleach)
        import bleach
        html = []
        for b in blocks:
            if b["type"] == "text":
                html.append(f"<p>{bleach.clean(b['content'])}</p>")
            elif b["type"] == "code":
                html.append(f"<pre><code>{bleach.clean(b['content'])}</code></pre>")
            elif b["type"] == "button":
                html.append(f'<button data-action="{b["action_id"]}">{bleach.clean(b["label"])}</button>')
        return "\n".join(html)

    raise ValueError(f"unknown channel: {channel_type}")

import asyncio, random
from .audit import audit

async def deliver_with_failover(user_id: int, blocks: list, urgency="normal"):
    user = await load_user(user_id)
    order = user.channel_preference or ["slack", "telegram", "web"]

    for ch_name in order:
        link = await get_link(user_id, ch_name)
        if not link:
            continue

        # retry exponencial: 0.5s, 1s, 2s (com jitter)
        for attempt in range(3):
            try:
                await CHANNELS[ch_name].push(user_id, blocks, link.external_id)
                await audit(user_id, channel=ch_name, event="delivered",
                            attempt=attempt, urgency=urgency)
                return ch_name   # canal usado fica no audit
            except RateLimitError:
                wait = (2 ** attempt) * 0.5 + random.uniform(0, 0.3)
                await asyncio.sleep(wait)
            except (ConnectionError, TimeoutError) as e:
                await audit(user_id, channel=ch_name, event="transient_fail",
                            attempt=attempt, error=str(e))
                await asyncio.sleep((2 ** attempt) * 0.5)
            except ChannelDownError:
                await audit(user_id, channel=ch_name, event="channel_down")
                break   # próximo canal, sem mais retry neste

    await audit(user_id, channel="none", event="all_failed", urgency=urgency)
    if urgency == "critical":
        await page_oncall(user_id, blocks)   # último recurso: humano
    return None