flowent 0.0.1 → 0.0.4

package/backend/tests/unit/channels/test_telegram_channel.py

@@ -0,0 +1,552 @@
+import asyncio
+
+import pytest
+
+from flowent.channels.telegram import (
+    IMAGE_INPUT_UNSUPPORTED_MESSAGE,
+    IMAGE_OUTPUT_UNSUPPORTED_MESSAGE,
+    PRIVATE_ONLY_MESSAGE,
+    TelegramChannel,
+)
+from flowent.models import Event, EventType
+from flowent.settings import (
+    Settings,
+    TelegramApprovedChat,
+    TelegramPendingChat,
+    TelegramSettings,
+)
+
+
+class DummyAssistant:
+    def __init__(self) -> None:
+        self.uuid = "assistant-1"
+        self.messages: list[object] = []
+
+    def enqueue_message(self, message) -> None:
+        self.messages.append(message)
+
+    def supports_input_image(self) -> bool:
+        return True
+
+
+class _FakeTelegramResponse:
+    def __init__(self, status_code: int, payload: dict[str, object]) -> None:
+        self.status_code = status_code
+        self._payload = payload
+
+    def json(self) -> dict[str, object]:
+        return self._payload
+
+
+class _FakeAsyncSession:
+    def __init__(self, response: _FakeTelegramResponse) -> None:
+        self._response = response
+        self.requests: list[tuple[str, dict[str, object]]] = []
+
+    async def __aenter__(self) -> "_FakeAsyncSession":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> bool:
+        return False
+
+    async def post(self, url: str, data: dict[str, object]):
+        self.requests.append((url, data))
+        return self._response
+
+
+def test_telegram_channel_replies_with_private_only_message_for_group_chat(
+    monkeypatch,
+):
+    settings = Settings(telegram=TelegramSettings(bot_token="123456:ABCDE"))
+    sent_messages: list[tuple[int, str, bool]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        sent_messages.append((chat_id, text, markdown))
+        return 1
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+
+    asyncio.run(
+        channel._process_update(
+            {
+                "message": {
+                    "from": {"id": 2002},
+                    "chat": {"id": -3003, "type": "group"},
+                    "text": "hello",
+                }
+            }
+        )
+    )
+
+    assert sent_messages == [(-3003, PRIVATE_ONLY_MESSAGE, False)]
+
+
+def test_telegram_channel_tracks_pending_private_chat_and_replies_with_chat_id(
+    monkeypatch,
+):
+    settings = Settings(telegram=TelegramSettings(bot_token="123456:ABCDE"))
+    saved: list[Settings] = []
+    sent_messages: list[tuple[int, str, bool]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.save_settings",
+        lambda current: saved.append(current),
+    )
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        sent_messages.append((chat_id, text, markdown))
+        return 1
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+
+    asyncio.run(
+        channel._process_update(
+            {
+                "message": {
+                    "from": {
+                        "id": 2002,
+                        "username": "alice",
+                        "first_name": "Alice",
+                    },
+                    "chat": {"id": 3003, "type": "private"},
+                    "text": "hello",
+                }
+            }
+        )
+    )
+
+    assert len(saved) == 1
+    assert settings.telegram.pending_chats == [
+        TelegramPendingChat(
+            chat_id=3003,
+            username="alice",
+            display_name="Alice",
+            first_seen_at=settings.telegram.pending_chats[0].first_seen_at,
+            last_seen_at=settings.telegram.pending_chats[0].last_seen_at,
+        )
+    ]
+    assert sent_messages == [
+        (
+            3003,
+            "⏳ This chat is pending approval in Flowent.\nChat ID: `3003`",
+            True,
+        )
+    ]
+
+
+def test_telegram_channel_delivers_messages_from_approved_private_chat(monkeypatch):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    assistant = DummyAssistant()
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.registry.get_assistant",
+        lambda: assistant,
+    )
+
+    channel = TelegramChannel()
+
+    asyncio.run(
+        channel._process_update(
+            {
+                "message": {
+                    "from": {"id": 1001},
+                    "chat": {"id": 4004, "type": "private"},
+                    "text": "check status",
+                }
+            }
+        )
+    )
+
+    assert len(assistant.messages) == 1
+    assert assistant.messages[0].from_id == "human"
+    assert assistant.messages[0].to_id == assistant.uuid
+    assert assistant.messages[0].content == "check status"
+
+
+def test_telegram_channel_rejects_image_input_from_approved_private_chat(monkeypatch):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    assistant = DummyAssistant()
+    sent_messages: list[tuple[int, str, bool]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.registry.get_assistant",
+        lambda: assistant,
+    )
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        sent_messages.append((chat_id, text, markdown))
+        return 1
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+
+    asyncio.run(
+        channel._process_update(
+            {
+                "message": {
+                    "from": {"id": 1001},
+                    "chat": {"id": 4004, "type": "private"},
+                    "caption": "look at this",
+                    "photo": [{"file_id": "photo-1"}],
+                }
+            }
+        )
+    )
+
+    assert assistant.messages == []
+    assert sent_messages == [(4004, IMAGE_INPUT_UNSUPPORTED_MESSAGE, False)]
+
+
+def test_telegram_channel_sends_typing_while_running_before_first_visible_text(
+    monkeypatch,
+):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    assistant = DummyAssistant()
+    sent_actions: list[tuple[int, str]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.registry.get_assistant",
+        lambda: assistant,
+    )
+
+    channel = TelegramChannel()
+
+    async def fake_send_chat_action(chat_id: int, *, action: str) -> None:
+        sent_actions.append((chat_id, action))
+
+    async def fake_sleep(_: float) -> None:
+        channel._assistant_running = False
+
+    monkeypatch.setattr(channel, "_send_chat_action", fake_send_chat_action)
+    monkeypatch.setattr("flowent.channels.telegram.asyncio.sleep", fake_sleep)
+
+    async def run_test() -> None:
+        await channel._process_event(
+            Event(
+                type=EventType.NODE_STATE_CHANGED,
+                agent_id=assistant.uuid,
+                data={"new_state": "running"},
+            )
+        )
+        assert channel._typing_task is not None
+        await channel._typing_task
+
+    asyncio.run(run_test())
+
+    assert sent_actions == [(4004, "typing")]
+
+
+def test_telegram_channel_stops_typing_after_first_visible_text(monkeypatch):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    sent_messages: list[tuple[int, str, bool]] = []
+    sent_actions: list[tuple[int, str]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        sent_messages.append((chat_id, text, markdown))
+        return 7
+
+    async def fake_send_chat_action(chat_id: int, *, action: str) -> None:
+        sent_actions.append((chat_id, action))
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+    monkeypatch.setattr(channel, "_send_chat_action", fake_send_chat_action)
+
+    async def run_test() -> None:
+        channel._assistant_running = True
+        await channel._handle_assistant_content("hello")
+        await channel._send_typing_feedback_once()
+
+    asyncio.run(run_test())
+
+    assert sent_messages == [(4004, "hello", False)]
+    assert sent_actions == []
+    assert channel._stream_message_ids == {4004: 7}
+
+
+def test_telegram_channel_sends_explicit_notice_for_image_output(monkeypatch):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    assistant = DummyAssistant()
+    sent_messages: list[tuple[int, str, bool]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.registry.get_assistant",
+        lambda: assistant,
+    )
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        sent_messages.append((chat_id, text, markdown))
+        return 1
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+
+    asyncio.run(
+        channel._process_event(
+            Event(
+                type=EventType.HISTORY_ENTRY_ADDED,
+                agent_id=assistant.uuid,
+                data={
+                    "type": "AssistantText",
+                    "parts": [{"type": "image", "asset_id": "asset-1"}],
+                },
+            )
+        )
+    )
+
+    assert sent_messages == [(4004, IMAGE_OUTPUT_UNSUPPORTED_MESSAGE, False)]
+
+
+def test_telegram_channel_ignores_tool_progress_events(monkeypatch):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    assistant = DummyAssistant()
+    broadcast_messages: list[str] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.registry.get_assistant",
+        lambda: assistant,
+    )
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        broadcast_messages.append(text)
+        return 1
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+
+    asyncio.run(
+        channel._process_event(
+            Event(
+                type=EventType.TOOL_CALLED,
+                agent_id=assistant.uuid,
+                data={"tool": "read"},
+            )
+        )
+    )
+
+    assert broadcast_messages == []
+
+
+@pytest.mark.parametrize("end_state", ["idle", "error", "terminated"])
+def test_telegram_channel_stops_without_placeholder_when_running_ends_no_content(
+    monkeypatch,
+    end_state,
+):
+    settings = Settings(
+        telegram=TelegramSettings(
+            bot_token="123456:ABCDE",
+            approved_chats=[
+                TelegramApprovedChat(
+                    chat_id=4004,
+                    username="alice",
+                    display_name="Alice",
+                    approved_at=1.0,
+                )
+            ],
+        )
+    )
+    assistant = DummyAssistant()
+    sent_messages: list[tuple[int, str, bool]] = []
+    sent_actions: list[tuple[int, str]] = []
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.registry.get_assistant",
+        lambda: assistant,
+    )
+
+    channel = TelegramChannel()
+
+    async def fake_send_message(chat_id: int, text: str, *, markdown: bool) -> int:
+        sent_messages.append((chat_id, text, markdown))
+        return 1
+
+    async def fake_send_chat_action(chat_id: int, *, action: str) -> None:
+        sent_actions.append((chat_id, action))
+
+    async def fake_sleep(_: float) -> None:
+        await channel._process_event(
+            Event(
+                type=EventType.NODE_STATE_CHANGED,
+                agent_id=assistant.uuid,
+                data={"new_state": end_state},
+            )
+        )
+
+    monkeypatch.setattr(channel, "_send_message", fake_send_message)
+    monkeypatch.setattr(channel, "_send_chat_action", fake_send_chat_action)
+    monkeypatch.setattr("flowent.channels.telegram.asyncio.sleep", fake_sleep)
+
+    async def run_test() -> None:
+        await channel._process_event(
+            Event(
+                type=EventType.NODE_STATE_CHANGED,
+                agent_id=assistant.uuid,
+                data={"new_state": "running"},
+            )
+        )
+        assert channel._typing_task is not None
+        await channel._typing_task
+
+    asyncio.run(run_test())
+
+    assert sent_actions == [(4004, "typing")]
+    assert sent_messages == []
+    assert channel._stream_message_ids == {}
+
+
+def test_telegram_channel_stop_cancels_typing_task_on_app_loop(monkeypatch):
+    cancelled: list[str] = []
+
+    class FakeTask:
+        def cancel(self) -> None:
+            cancelled.append("typing")
+
+    class FakeLoop:
+        def __init__(self) -> None:
+            self.calls: list[str] = []
+
+        def is_closed(self) -> bool:
+            return False
+
+        def call_soon_threadsafe(self, callback) -> None:
+            self.calls.append(callback.__name__)
+            callback()
+
+    monkeypatch.setattr(
+        "flowent.channels.telegram.event_bus.unsubscribe", lambda _: None
+    )
+
+    channel = TelegramChannel()
+    app_loop = FakeLoop()
+    polling_loop = FakeLoop()
+    channel._app_loop = app_loop
+    channel._thread_loop = polling_loop
+    channel._typing_task = FakeTask()
+
+    channel.stop()
+
+    assert app_loop.calls == ["cancel"]
+    assert polling_loop.calls == []
+    assert cancelled == ["typing"]
+
+
+def test_telegram_channel_call_api_uses_shared_async_transport(monkeypatch):
+    settings = Settings(telegram=TelegramSettings(bot_token="123456:ABCDE"))
+    fake_session = _FakeAsyncSession(
+        _FakeTelegramResponse(200, {"ok": True, "result": {"message_id": 1}})
+    )
+
+    monkeypatch.setattr("flowent.channels.telegram.get_settings", lambda: settings)
+    monkeypatch.setattr(
+        "flowent.channels.telegram.create_async_http_session",
+        lambda timeout: fake_session,
+    )
+
+    channel = TelegramChannel()
+
+    result = asyncio.run(
+        channel._call_api(
+            "sendMessage",
+            {"chat_id": 3003, "text": "hello"},
+            parse_mode="Markdown",
+        )
+    )
+
+    assert result == {"message_id": 1}
+    assert fake_session.requests == [
+        (
+            "https://api.telegram.org/bot123456:ABCDE/sendMessage",
+            {"chat_id": 3003, "text": "hello", "parse_mode": "Markdown"},
+        )
+    ]

package/backend/tests/unit/logging/test_logging.py

@@ -0,0 +1,132 @@
+import logging
+import re
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+from loguru import logger
+
+from flowent.logging import (
+    HealthcheckAccessFilter,
+    configure_uvicorn_access_logging,
+    detect_runtime_mode,
+    setup_logging,
+)
+
+
+@pytest.fixture(autouse=True)
+def cleanup_loguru() -> Iterator[None]:
+    yield
+    logger.remove()
+
+
+def test_detect_runtime_mode_from_fastapi_command() -> None:
+    assert detect_runtime_mode(["/venv/bin/fastapi", "dev", "app/main.py"]) == "dev"
+    assert detect_runtime_mode(["/venv/bin/fastapi", "run", "app/main.py"]) == "release"
+
+
+def test_detect_runtime_mode_from_reload_flag() -> None:
+    assert detect_runtime_mode(["uvicorn", "flowent.main:app", "--reload"]) == "dev"
+    assert detect_runtime_mode(["uvicorn", "flowent.main:app"]) == "release"
+
+
+def test_setup_logging_creates_timestamped_file_and_prunes_old_logs(
+    tmp_path: Path,
+) -> None:
+    log_dir = tmp_path / "logs"
+    log_dir.mkdir()
+    for i in range(1, 12):
+        (log_dir / f"{i}.log").write_text(f"old-{i}", encoding="utf-8")
+
+    setup_logging(argv=["fastapi", "run"], runtime_dir=tmp_path)
+
+    log_files = sorted(path.name for path in log_dir.iterdir() if path.is_file())
+    assert len(log_files) == 10
+    assert "1.log" not in log_files
+    assert "2.log" not in log_files
+    assert any(
+        re.fullmatch(r"\d{4}-\d{2}-\d{2}_\d{6}_\d+\.log", path) for path in log_files
+    )
+
+
+def test_setup_logging_writes_source_and_agent_id_to_file(tmp_path: Path) -> None:
+    setup_logging(argv=["fastapi", "dev"], runtime_dir=tmp_path)
+
+    with logger.contextualize(agent_id="agent-123"):
+        logger.info("hello file log")
+
+    log_files = sorted((tmp_path / "logs").iterdir())
+    content = log_files[-1].read_text(encoding="utf-8")
+
+    assert "hello file log" in content
+    assert "agent:agent-123" in content
+    assert "test_setup_logging_writes_source_and_agent_id_to_file" in content
+    assert "hello file log\n\n" not in content
+
+
+def test_setup_logging_sets_console_level_from_runtime_mode(
+    capsys,
+    tmp_path: Path,
+) -> None:
+    setup_logging(argv=["fastapi", "run"], runtime_dir=tmp_path)
+    logger.debug("hidden release debug")
+    logger.info("visible release info")
+    release_output = capsys.readouterr().err
+
+    setup_logging(argv=["fastapi", "dev"], runtime_dir=tmp_path)
+    logger.debug("visible dev debug")
+    dev_output = capsys.readouterr().err
+
+    assert "hidden release debug" not in release_output
+    assert "visible release info" in release_output
+    assert "visible release info\n\n" not in release_output
+    assert "visible dev debug" in dev_output
+
+
+def test_healthcheck_access_filter_blocks_health_endpoint() -> None:
+    access_filter = HealthcheckAccessFilter()
+    record = logging.LogRecord(
+        name="uvicorn.access",
+        level=logging.INFO,
+        pathname=__file__,
+        lineno=1,
+        msg='%s - "%s %s HTTP/%s" %d',
+        args=("127.0.0.1:12345", "GET", "/health?source=docker", "1.1", 200),
+        exc_info=None,
+    )
+
+    assert access_filter.filter(record) is False
+
+
+def test_healthcheck_access_filter_keeps_other_requests() -> None:
+    access_filter = HealthcheckAccessFilter()
+    record = logging.LogRecord(
+        name="uvicorn.access",
+        level=logging.INFO,
+        pathname=__file__,
+        lineno=1,
+        msg='%s - "%s %s HTTP/%s" %d',
+        args=("127.0.0.1:12345", "GET", "/api/meta", "1.1", 200),
+        exc_info=None,
+    )
+
+    assert access_filter.filter(record) is True
+
+
+def test_configure_uvicorn_access_logging_installs_filter_once() -> None:
+    access_logger = logging.getLogger("uvicorn.access")
+    original_filters = list(access_logger.filters)
+    access_logger.filters = [
+        f for f in access_logger.filters if not isinstance(f, HealthcheckAccessFilter)
+    ]
+
+    try:
+        configure_uvicorn_access_logging()
+        configure_uvicorn_access_logging()
+
+        filters = [
+            f for f in access_logger.filters if isinstance(f, HealthcheckAccessFilter)
+        ]
+        assert len(filters) == 1
+    finally:
+        access_logger.filters = original_filters