linkgravity 1.3.0 → 1.4.1

package/src/main_telegram.py

@@ -0,0 +1,250 @@
+"""Telegram bot setup. Runs in the same process as Discord (see main.py),
+which starts both concurrently when both platforms are enabled."""
+
+import asyncio
+import os
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from telegram import BotCommand, InlineKeyboardButton, InlineKeyboardMarkup, Update
+from telegram.ext import Application, ApplicationBuilder, CallbackQueryHandler, CommandHandler, MessageHandler, filters
+
+from config import TELEGRAM_TOKEN, allowed, bot_settings, logger, save_bot_settings, session_manager
+from core.atomic_io import atomic_write_json, safe_load_json
+from handlers.message_router import handle_message
+from messengers.registry import register_adapter
+from messengers.telegram_adapter import TelegramAdapter, markdown_to_telegram_html, safe_query_edit
+from utils.utils import get_default_cwd
+
+
+def _start_session(chat_id: int, user_id: int) -> dict:
+    session = {
+        "status": "pending",
+        "platform": "telegram",
+        "user_id": user_id,
+        "cwd": get_default_cwd(),
+        "model": bot_settings.get("default_model") or None,
+        "conversation_id": None,
+        "created_at": datetime.now().isoformat(),
+    }
+    session_manager.set_session(str(chat_id), session)
+    return session
+
+
+async def cmd_new(update: Update, context) -> None:
+    user = update.effective_user
+    chat_id = update.effective_chat.id
+    adapter: TelegramAdapter = context.bot_data["adapter"]
+
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Permission denied.")
+        return
+
+    if session_manager.get_session(str(chat_id)):
+        prompt_id = uuid.uuid4().hex[:12]
+        confirm_key, cancel_key = f"{prompt_id}:confirm", f"{prompt_id}:cancel"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton("✅ Yes, start new", callback_data=confirm_key),
+                    InlineKeyboardButton("Cancel", callback_data=cancel_key),
+                ]
+            ]
+        )
+        await update.message.reply_text(
+            "⚠️ A session is already active in this chat. Starting a new one will lose its context. Continue?",
+            reply_markup=keyboard,
+        )
+
+        async def confirm(query):
+            await query.answer()
+            await query.edit_message_text("🆕 Starting a new session...", reply_markup=None)
+            _start_session(chat_id, user.id)
+            await adapter.send_message(chat_id, "✅ **Ready for new session!** Send a message to begin.")
+
+        async def cancel(query):
+            await query.answer()
+            await query.edit_message_text("Cancelled.", reply_markup=None)
+
+        adapter.register_callback(confirm_key, confirm)
+        adapter.register_callback(cancel_key, cancel)
+        return
+
+    _start_session(chat_id, user.id)
+    await update.message.reply_text(
+        markdown_to_telegram_html("✅ **Ready for new session!** Send a message to begin."), parse_mode="HTML"
+    )
+
+
+async def cmd_model(update: Update, context) -> None:
+    user = update.effective_user
+    chat_id = update.effective_chat.id
+    adapter: TelegramAdapter = context.bot_data["adapter"]
+
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Permission Denied")
+        return
+
+    session = session_manager.get_session(str(chat_id))
+    if not session:
+        await update.message.reply_text("⚠️ No active session here. Start one with /new first.")
+        return
+
+    from cogs.general_cog import load_cached_models
+
+    cached_models = load_cached_models()
+    current_model = session.get("model") or bot_settings.get("default_model")
+
+    def _apply_model(final_model: str) -> str:
+        session_manager.update_session(str(chat_id), "model", final_model)
+        bot_settings["default_model"] = final_model
+        save_bot_settings(bot_settings)
+        return final_model
+
+    if not context.args:
+        prompt_id = uuid.uuid4().hex[:12]
+        keyboard = []
+        for m in cached_models:
+            key = f"{prompt_id}:{m}"
+            label = ("✅ " if m == current_model else "") + m
+
+            async def pick(query, m=m):
+                final_model = _apply_model(m)
+                await query.answer()
+                await safe_query_edit(
+                    query,
+                    text=markdown_to_telegram_html(f"🤖 Model changed: **{final_model}**"),
+                    parse_mode="HTML",
+                )
+
+            adapter.register_callback(key, pick)
+            keyboard.append([InlineKeyboardButton(label, callback_data=key)])
+
+        await update.message.reply_text(
+            "Pick a model (or send /model <name> to type one):", reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        return
+
+    requested = " ".join(context.args)
+    exact = next((m for m in cached_models if m.lower() == requested.lower()), None)
+    partial = next((m for m in cached_models if requested.lower() in m.lower()), None)
+    final_model = _apply_model(exact or partial or requested)
+
+    await adapter.send_message(
+        chat_id, f"🤖 Model changed: **{final_model}**\n💾 Also set as the default for new sessions."
+    )
+
+
+async def cmd_credit(update: Update, context) -> None:
+    user = update.effective_user
+    adapter: TelegramAdapter = context.bot_data["adapter"]
+
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Denied")
+        return
+
+    settings_path = Path(os.getenv("HOME", "/root")) / ".gemini/antigravity-cli/settings.json"
+    current = bool(safe_load_json(settings_path, {}, logger=logger).get("useG1Credits", False))
+
+    async def set_credit(use_credits: bool, query) -> None:
+        try:
+            data = safe_load_json(settings_path, {}, logger=logger)
+            data["useG1Credits"] = use_credits
+            atomic_write_json(settings_path, data)
+        except Exception as e:
+            await query.answer()
+            await safe_query_edit(query, text=f"⚠️ Failed to update settings: {e}")
+            return
+
+        status_text = "🟢 **ON** (Using AI Credits)" if use_credits else "🔴 **OFF** (Using default/free model)"
+        await query.answer()
+        await safe_query_edit(
+            query,
+            text=markdown_to_telegram_html(f"✅ AI Credit setting updated: {status_text}"),
+            parse_mode="HTML",
+        )
+
+    prompt_id = uuid.uuid4().hex[:12]
+    on_key, off_key = f"{prompt_id}:on", f"{prompt_id}:off"
+    adapter.register_callback(on_key, lambda query: set_credit(True, query))
+    adapter.register_callback(off_key, lambda query: set_credit(False, query))
+
+    keyboard = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(("✅ " if current else "") + "🟢 ON", callback_data=on_key),
+                InlineKeyboardButton(("✅ " if not current else "") + "🔴 OFF", callback_data=off_key),
+            ]
+        ]
+    )
+    await update.message.reply_text("AI Credits:", reply_markup=keyboard)
+
+
+async def on_message(update: Update, context) -> None:
+    await handle_message(None, update, context.bot_data["adapter"])
+
+
+async def on_error(update: object, context) -> None:
+    logger.exception(f"Unhandled exception in Telegram update: {context.error}")
+    if isinstance(update, Update) and update.effective_chat:
+        try:
+            adapter = context.bot_data["adapter"]
+            await adapter.send_message(
+                update.effective_chat.id,
+                "⚠️ **An internal bot error has occurred.** Please contact the developer or check the server logs.",
+            )
+        except Exception:
+            pass
+
+
+async def on_ready(app: Application) -> None:
+    await app.bot.set_my_commands(
+        [
+            BotCommand("new", "Start a new session (or /start)"),
+            BotCommand("model", "Change the AI model for this session"),
+            BotCommand("credit", "Turn AI Credits on/off"),
+        ]
+    )
+    logger.info(f"✅ Bot is fully online and ready! Logged in as @{app.bot.username}")
+
+
+def build_application() -> Application:
+    app = ApplicationBuilder().token(TELEGRAM_TOKEN).post_init(on_ready).concurrent_updates(True).build()
+    adapter = TelegramAdapter(app.bot)
+    app.bot_data["adapter"] = adapter
+    register_adapter("telegram", adapter)
+
+    app.add_handler(CommandHandler(["new", "start"], cmd_new))
+    app.add_handler(CommandHandler("model", cmd_model))
+    app.add_handler(CommandHandler("credit", cmd_credit))
+    app.add_handler(CallbackQueryHandler(adapter.handle_callback_query))
+    app.add_handler(MessageHandler(filters.ALL & ~filters.COMMAND, on_message))
+    app.add_error_handler(on_error)
+    return app
+
+
+async def run_telegram(stop_event: asyncio.Event) -> None:
+    """Runs the Telegram bot manually (not via Application.run_polling(),
+    which blocks and manages its own event loop) so it can run alongside
+    Discord in the same process. See PTB docs on combining Application
+    with other asyncio frameworks."""
+    if not TELEGRAM_TOKEN:
+        logger.critical("Missing TELEGRAM_TOKEN - set telegram_token in lgy.json first.")
+        return
+
+    app = build_application()
+    logger.info("✅ Telegram bot starting (polling mode)...")
+    await app.initialize()
+    if app.post_init:  # not auto-called outside run_polling()/run_webhook()
+        await app.post_init(app)
+    await app.start()
+    await app.updater.start_polling(allowed_updates=Update.ALL_TYPES)
+    try:
+        await stop_event.wait()
+    finally:
+        await app.updater.stop()
+        await app.stop()
+        await app.shutdown()
+        if app.post_shutdown:  # same gotcha as post_init: not auto-called here
+            await app.post_shutdown(app)

package/src/messengers/base.py

@@ -9,9 +9,35 @@ this interface; see VoiceCapable.
 """
 
 from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
 from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from typing import Any, Protocol, runtime_checkable
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class IncomingAttachment:
+    """A file on an inbound message; reader defers fetching bytes until needed."""
+
+    filename: str
+    content_type: str | None
+    reader: Callable[[], Awaitable[bytes]]
+
+    async def read(self) -> bytes:
+        return await self.reader()
+
+
+@dataclass
+class IncomingMessage:
+    """Platform-agnostic inbound message - adapters build this, handlers never see raw platform types."""
+
+    author_id: Any
+    platform: str
+    content: str
+    conversation_id: str
+    conversation_ref: Any
+    attachments: list[IncomingAttachment] = field(default_factory=list)
+    add_reaction: Callable[[str], Awaitable[None]] | None = None
 
 
 @dataclass
@@ -42,6 +68,12 @@ class PromptHandle(ABC):
 
 class MessengerAdapter(ABC):
     platform_name: str = "unknown"
+    supports_renaming: bool = True  # False skips the AI title-generation call - its result would go nowhere anyway
+
+    @abstractmethod
+    def to_incoming_message(self, raw_event: Any) -> IncomingMessage | None:
+        """Converts a native platform event to IncomingMessage, or None to ignore it (bot/system messages)."""
+        raise NotImplementedError
 
     @abstractmethod
     async def send_message(self, conversation_ref: Any, text: str) -> Any:
@@ -98,8 +130,15 @@ class MessengerAdapter(ABC):
         return isinstance(self, VoiceCapable)
 
 
-@runtime_checkable
-class VoiceCapable(Protocol):
-    async def join_voice(self, guild_ref: Any, channel_ref: Any) -> None: ...
-    async def leave_voice(self, guild_ref: Any) -> None: ...
-    async def play_tts(self, guild_ref: Any, audio_bytes: bytes) -> None: ...
+class VoiceCapable(ABC):
+    @abstractmethod
+    async def join_voice(self, guild_ref: Any, channel_ref: Any) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def leave_voice(self, guild_ref: Any) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def play_tts(self, guild_ref: Any, audio_bytes: bytes) -> None:
+        raise NotImplementedError

package/src/messengers/discord_adapter.py

@@ -9,6 +9,8 @@ import discord
 
 from config import logger
 from messengers.base import (
+    IncomingAttachment,
+    IncomingMessage,
     MessengerAdapter,
     PromptHandle,
     ScopeOption,
@@ -17,6 +19,19 @@ from messengers.base import (
 )
 
 
+class _ErrorLoggingView(discord.ui.View):
+    async def on_error(self, interaction: discord.Interaction, error: Exception, item) -> None:
+        logger.exception(f"Discord button interaction error: {error}")
+        error_msg = "⚠️ **An error occurred while processing this button.** Please try again later or check the logs."
+        try:
+            if interaction.response.is_done():
+                await interaction.followup.send(error_msg, ephemeral=True)
+            else:
+                await interaction.response.send_message(error_msg, ephemeral=True)
+        except Exception:
+            pass
+
+
 class _DiscordPromptHandle(PromptHandle):
     def __init__(self, embed: discord.Embed, view: discord.ui.View):
         self.embed = embed
@@ -25,7 +40,13 @@ class _DiscordPromptHandle(PromptHandle):
         self.outcome: ToolApprovalOutcome | None = None
 
     async def send(self, conversation_ref: discord.abc.Messageable) -> discord.Message:
-        self.message = await conversation_ref.send(embed=self.embed, view=self.view)
+        if self.embed.description and len(self.embed.description) > 4000:
+            self.embed.description = self.embed.description[:3997] + "..."
+        try:
+            self.message = await conversation_ref.send(embed=self.embed, view=self.view)
+        except discord.HTTPException as e:
+            logger.error(f"Failed to send Discord prompt message: {e}")
+            raise
         return self.message
 
     async def finalize(self) -> None:
@@ -47,10 +68,41 @@ class DiscordAdapter(MessengerAdapter):
     def __init__(self, bot: discord.Client):
         self.bot = bot
 
+    # -- inbound -------------------------------------------------------------
+
+    def to_incoming_message(self, raw_event: discord.Message) -> IncomingMessage | None:
+        message = raw_event
+        if message.type not in (discord.MessageType.default, discord.MessageType.reply):
+            return None
+        if message.author.bot:
+            return None
+
+        attachments = [
+            IncomingAttachment(filename=att.filename, content_type=att.content_type, reader=att.read)
+            for att in message.attachments
+        ]
+
+        async def add_reaction(emoji: str) -> None:
+            await message.add_reaction(emoji)
+
+        return IncomingMessage(
+            author_id=message.author.id,
+            platform=self.platform_name,
+            content=message.content,
+            conversation_id=str(message.channel.id),
+            conversation_ref=message.channel,
+            attachments=attachments,
+            add_reaction=add_reaction,
+        )
+
     # -- plain messaging ---------------------------------------------------
 
     async def send_message(self, conversation_ref: discord.abc.Messageable, text: str) -> discord.Message:
-        return await conversation_ref.send(text)
+        try:
+            return await conversation_ref.send(text)
+        except discord.HTTPException as e:
+            logger.error(f"Failed to send Discord message: {e}")
+            raise
 
     async def edit_message(self, message_ref: discord.Message, text: str) -> bool:
         try:
@@ -69,7 +121,11 @@ class DiscordAdapter(MessengerAdapter):
     async def send_files(self, conversation_ref: discord.abc.Messageable, file_paths: list[str]) -> None:
         if not file_paths:
             return
-        await conversation_ref.send(files=[discord.File(p) for p in file_paths])
+        try:
+            await conversation_ref.send(files=[discord.File(p) for p in file_paths])
+        except discord.HTTPException as e:
+            logger.error(f"Failed to send Discord files: {e}")
+            raise
 
     def resolve_conversation(self, conversation_id: str) -> Any:
         try:
@@ -98,7 +154,7 @@ class DiscordAdapter(MessengerAdapter):
         scope_options: list[ScopeOption],
     ) -> PromptHandle:
         embed = discord.Embed(title=title, description=body, color=discord.Color.orange())
-        view = discord.ui.View(timeout=None)
+        view = _ErrorLoggingView(timeout=None)
         handle = _DiscordPromptHandle(embed, view)
 
         def make_callback(decision: str, scope: ScopeOption | None):
@@ -154,7 +210,7 @@ class DiscordAdapter(MessengerAdapter):
             description=f"**{question}**\n\nPlease select an answer below.",
             color=discord.Color.blue(),
         )
-        view = discord.ui.View(timeout=None)
+        view = _ErrorLoggingView(timeout=None)
         handle = _DiscordPromptHandle(embed, view)
 
         async def _resolve(interaction: discord.Interaction, text: str, note: str):
@@ -214,6 +270,17 @@ class DiscordAdapter(MessengerAdapter):
                 async def on_submit(modal_self, interaction: discord.Interaction):
                     await _resolve(interaction, modal_self.answer.value, "Selected (Write in)")
 
+                async def on_error(modal_self, interaction: discord.Interaction, error: Exception) -> None:
+                    logger.exception(f"Discord modal submission error: {error}")
+                    error_msg = "⚠️ **An error occurred while processing your response.** Please try again later or check the logs."
+                    try:
+                        if interaction.response.is_done():
+                            await interaction.followup.send(error_msg, ephemeral=True)
+                        else:
+                            await interaction.response.send_message(error_msg, ephemeral=True)
+                    except Exception:
+                        pass
+
             async def write_in_callback(interaction: discord.Interaction):
                 await interaction.response.send_modal(WriteInModal())
 

package/src/messengers/registry.py

@@ -1,19 +1,35 @@
-"""Process-wide messenger adapter instance, set once at startup by
-main.py. Matches the codebase's existing singleton pattern (see
-config.session_manager) so deep call sites don't need the adapter
-threaded through every signature."""
+"""Per-platform messenger adapter registry, populated once at startup by
+main.py. Both bots now share one process, so callers must say which
+platform they mean - either directly (voice/Discord-only code) or by
+looking up which platform a given thread_id/conversation belongs to."""
 
 from messengers.base import MessengerAdapter
 
-_adapter: MessengerAdapter | None = None
+_adapters: dict[str, MessengerAdapter] = {}
 
 
-def set_adapter(adapter: MessengerAdapter) -> None:
-    global _adapter
-    _adapter = adapter
+def register_adapter(platform: str, adapter: MessengerAdapter) -> None:
+    _adapters[platform] = adapter
 
 
-def get_adapter() -> MessengerAdapter:
-    if _adapter is None:
-        raise RuntimeError("Messenger adapter not initialized - main.py must call set_adapter() at startup.")
-    return _adapter
+def get_adapter_for_platform(platform: str) -> MessengerAdapter:
+    if platform not in _adapters:
+        raise RuntimeError(f"No adapter registered for platform {platform!r} - is it enabled in lgy.json?")
+    return _adapters[platform]
+
+
+def get_adapter_for_thread(thread_id: str) -> MessengerAdapter:
+    from config import session_manager
+
+    session = session_manager.get_session(thread_id) or {}
+    platform = session.get("platform", "discord")  # pre-multi-platform sessions have no tag - assume discord
+    return get_adapter_for_platform(platform)
+
+
+def get_adapter_for_conv_id(conv_id: str) -> MessengerAdapter | None:
+    from config import session_manager
+
+    for _thread_id, sess in session_manager.get_all_sessions().items():
+        if sess.get("conversation_id") == conv_id:
+            return get_adapter_for_platform(sess.get("platform", "discord"))
+    return None