machinaos 0.0.76 → 0.0.78

package/server/nodes/telegram/_service.py

@@ -49,6 +49,8 @@ from telegram.error import BadRequest, NetworkError
 from telegram.ext import Application, ContextTypes, MessageHandler, filters
 from telegram.helpers import escape_markdown
 
+from services.plugin.singleton import ServiceSingleton
+
 from ._credentials import TelegramCredential
 
 logger = logging.getLogger(__name__)
@@ -99,10 +101,14 @@ def _split_text(text: str, limit: int) -> list[str]:
     return chunks
 
 
-class TelegramService:
-    """Singleton service for Telegram bot operations."""
+class TelegramService(ServiceSingleton):
+    """Singleton service for Telegram bot operations.
+
+    Inherits :meth:`ServiceSingleton.instance` for the lazy accessor.
+    Overrides :meth:`reset_instance` because telegram has a side effect
+    on reset — it must drain the bot's polling task before clearing.
+    """
 
-    _instance: Optional["TelegramService"] = None
     _lock = asyncio.Lock()
 
     def __init__(self):
@@ -115,15 +121,10 @@ class TelegramService:
         self._owner_chat_id: Optional[int] = None
 
     @classmethod
-    def get_instance(cls) -> "TelegramService":
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
-
-    @classmethod
-    async def reset_instance(cls):
-        if cls._instance:
-            await cls._instance.disconnect()
+    async def reset_instance(cls):  # type: ignore[override]
+        existing = cls.__dict__.get("_instance")
+        if existing is not None:
+            await existing.disconnect()
             cls._instance = None
 
     @property
@@ -256,12 +257,11 @@ class TelegramService:
                 }
                 logger.info(f"[Telegram] Bot validated: @{me.username} (ID: {me.id})")
 
-                self._polling_task = asyncio.create_task(self._run_polling())
-                self._connected = True
-
-                await self._broadcast_status()
-
-                # Hydrate runtime owner_chat_id from stored credential.
+                # Hydrate runtime owner_chat_id from stored credential
+                # BEFORE polling starts so the pre-poll peek below can
+                # short-circuit when we already know the owner. (Was
+                # previously after polling -- race-prone with the
+                # capture path in _on_message_received.)
                 saved_owner = secrets.get("telegram_owner_chat_id")
                 if saved_owner is None:
                     try:
@@ -276,6 +276,28 @@ class TelegramService:
                     except (TypeError, ValueError):
                         pass
 
+                # Pre-poll peek for historical owner capture.
+                # Polling starts with drop_pending_updates=True
+                # (correct hygiene for operational events -- we do
+                # not want stale group spam replaying on every
+                # restart) but that ALSO drops any DM the user sent
+                # before the bot connected. Without this peek the
+                # only path to owner capture is "DM the bot AFTER
+                # polling has started", which is the surprising UX
+                # that produces "Bot owner not detected" on every
+                # fresh setup. get_updates() with no offset returns
+                # the same pending queue without advancing it, so
+                # the subsequent start_polling drop-pass is a no-op
+                # for these messages -- they were going to be
+                # dropped anyway, we just inspect them first.
+                if self._owner_chat_id is None:
+                    await self._capture_owner_from_pending_updates()
+
+                self._polling_task = asyncio.create_task(self._run_polling())
+                self._connected = True
+
+                await self._broadcast_status()
+
                 logger.info(f"[Telegram] Connected and polling started for @{me.username}")
                 return {
                     "success": True,
@@ -354,36 +376,116 @@ class TelegramService:
             self._connected = False
             await self._broadcast_status()
 
+    async def _capture_owner_from_pending_updates(self) -> None:
+        """Inspect the bot's pending update queue (24h Telegram retention)
+        for any private message and capture the owner if found. Called
+        from connect() before polling starts -- after polling begins the
+        ``drop_pending_updates=True`` flag throws these away unread.
+
+        Uses the same atomic-write-through invariant as
+        ``_on_message_received``: persist FIRST, set in-memory only on
+        successful persist, so a restart can re-capture cleanly if the
+        DB write fails.
+        """
+        try:
+            # offset=None / 0 returns the queue without advancing the
+            # confirmed offset. allowed_updates=["message"] skips
+            # callback_query / poll / inline_query payloads we don't
+            # care about for owner capture.
+            pending = await self._bot.get_updates(
+                timeout=0,
+                allowed_updates=["message"],
+            )
+        except Exception as e:
+            logger.warning(
+                f"[Telegram] Pre-poll owner-capture peek failed "
+                f"({type(e).__name__}): {e}. Owner capture will fall "
+                f"back to live polling once the user DMs the bot.",
+            )
+            return
+
+        for upd in pending:
+            m = upd.message
+            if not (m and m.chat and m.chat.type == "private" and m.from_user):
+                continue
+            captured_id = m.from_user.id
+            try:
+                from services.plugin.deps import get_auth_service
+                await get_auth_service().store_api_key(
+                    "telegram_owner_chat_id",
+                    str(captured_id),
+                    models=[],
+                )
+            except Exception as persist_err:
+                logger.error(
+                    f"[Telegram] FAILED to persist retroactively-captured "
+                    f"owner {captured_id}: {persist_err}. Workaround: "
+                    f"set TELEGRAM_OWNER_CHAT_ID={captured_id} in .env",
+                    exc_info=True,
+                )
+                return
+            self._owner_chat_id = captured_id
+            logger.info(
+                f"[Telegram] Owner retroactively captured from pending "
+                f"updates: @{m.from_user.username} (ID: {captured_id})"
+            )
+            return
+
     async def _on_message_received(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
         try:
             if not update.message:
                 return
             msg = update.message
 
-            # Auto-capture bot owner from first private message
+            # Auto-capture bot owner from first private message.
+            # ATOMIC WRITE-THROUGH: persist to credentials DB FIRST, set
+            # in-memory only on success. The previous order
+            # (in-memory then await persist, with WARNING-level logging
+            # of failures) had a silent failure mode: if the persist
+            # raised, the rest of the process lifetime worked correctly,
+            # then the next restart wiped in-memory and DB had nothing
+            # -- subsequent telegramSend(recipient_type=self) failed
+            # forever with "Bot owner not detected" and no trace of
+            # what went wrong. The new order preserves the invariant
+            # "in-memory has owner => DB has owner" so a restart can
+            # always re-capture from the next inbound private message.
             if (
                 self._owner_chat_id is None
                 and msg.chat.type == "private"
                 and msg.from_user
             ):
-                self._owner_chat_id = msg.from_user.id
-                logger.info(
-                    f"[Telegram] Owner detected: @{msg.from_user.username} "
-                    f"(ID: {msg.from_user.id})"
-                )
+                captured_id = msg.from_user.id
+                persist_ok = False
                 try:
-                    from core.container import container
-                    auth = container.auth_service()
-                    await auth.store_api_key(
+                    from services.plugin.deps import get_auth_service
+                    await get_auth_service().store_api_key(
                         "telegram_owner_chat_id",
-                        str(msg.from_user.id),
+                        str(captured_id),
                         models=[],
                     )
+                    persist_ok = True
                 except Exception as persist_err:
-                    logger.warning(
-                        f"[Telegram] Failed to persist owner chat_id: {persist_err}"
+                    # ERROR-level so the failure surfaces in default
+                    # uvicorn output, not just DEBUG. Includes the
+                    # captured id so the user can manually set
+                    # TELEGRAM_OWNER_CHAT_ID in .env as an immediate
+                    # workaround. exc_info=True so the underlying
+                    # cause (encryption not initialised, DB locked,
+                    # disk full, ...) is visible.
+                    logger.error(
+                        f"[Telegram] FAILED to persist owner chat_id "
+                        f"{captured_id}: {persist_err}. The bot will not "
+                        f"recover this binding on restart. Workaround: "
+                        f"set TELEGRAM_OWNER_CHAT_ID={captured_id} in .env",
+                        exc_info=True,
                     )
-                await self._broadcast_status()
+                if persist_ok:
+                    self._owner_chat_id = captured_id
+                    logger.info(
+                        f"[Telegram] Owner detected and persisted: "
+                        f"@{msg.from_user.username} (ID: {captured_id})"
+                    )
+                    await self._broadcast_status()
 
             event_data = self._format_message(msg)
             logger.info(
@@ -727,4 +829,4 @@ class TelegramService:
 
 def get_telegram_service() -> TelegramService:
     """Get TelegramService singleton instance."""
-    return TelegramService.get_instance()
+    return TelegramService.instance()

package/server/nodes/telegram/telegram_send.py

@@ -1,7 +1,7 @@
 """Telegram Send — Wave 11.C migration.
 
-Dual-purpose: workflow ActionNode + AI tool. The Telegram bot token
-lives in ``auth_service`` under ``telegram_bot_token``. Plugin
+Workflow-only ActionNode (no AI-tool exposure). The Telegram bot
+token lives in ``auth_service`` under ``telegram_bot_token``. Plugin
 delegates to the legacy ``handle_telegram_send`` handler during
 thin-migration; 11.E converts to a declarative ``TelegramCredential``.
 """
@@ -148,7 +148,7 @@ class TelegramSendNode(ActionNode):
     type = "telegramSend"
     display_name = "Telegram Send"
     subtitle = "Send Message"
-    group = ("social", "tool")
+    group = ("social",)
     description = "Send text, photo, document, location, or contact via Telegram bot"
     component_kind = "square"
     handles = (
@@ -160,7 +160,6 @@ class TelegramSendNode(ActionNode):
     annotations = {"destructive": False, "readonly": False, "open_world": True}
     credentials = (TelegramCredential,)
     task_queue = TaskQueue.MESSAGING
-    usable_as_tool = True
 
     Params = TelegramSendParams
     Output = TelegramSendOutput
@@ -183,8 +182,8 @@ class TelegramSendNode(ActionNode):
             chat_id = service.owner_chat_id
             if not chat_id:
                 try:
-                    from core.container import container
-                    saved = await container.auth_service().get_api_key("telegram_owner_chat_id")
+                    from services.plugin.deps import get_auth_service
+                    saved = await get_auth_service().get_api_key("telegram_owner_chat_id")
                     if saved:
                         owner_id = int(saved)
                         await service.set_owner(owner_id)

package/server/nodes/text/file_handler.py

@@ -63,9 +63,9 @@ class FileHandlerNode(ActionNode):
 
     @Operation("wrap")
     async def wrap(self, ctx: NodeContext, params: FileHandlerParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_text_service
 
-        text_service = container.text_service()
+        text_service = get_text_service()
         # Pass schema-canonical snake_case through to the service. The
         # service's *output* dict still carries camelCase keys
         # (`fileName` / `fileType`) by historical wire contract -- the

package/server/nodes/text/text_generator.py

@@ -44,9 +44,9 @@ class TextGeneratorNode(ActionNode):
 
     @Operation("generate")
     async def generate(self, ctx: NodeContext, params: TextGeneratorParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_text_service
 
-        text_service = container.text_service()
+        text_service = get_text_service()
         response = await text_service.execute_text_generator(
             ctx.node_id, params.model_dump(),
         )