linkgravity 1.3.0 → 1.4.0

package/src/config.py

@@ -7,8 +7,7 @@ WORKSPACE_DIR = Path.home() / ".gemini" / "linkgravity"
 WORKSPACE_DIR.mkdir(parents=True, exist_ok=True)
 DATA_DIR = WORKSPACE_DIR / "data"
 DATA_DIR.mkdir(parents=True, exist_ok=True)
-# Per-user wake-word recordings + built .rpw reference (see EnrollmentManager).
-# Defined early so load_bot_settings' migration below can read it.
+# Per-user wake-word recordings (see EnrollmentManager); defined early so load_bot_settings' migration below can read it.
 WAKE_REF_DIR = WORKSPACE_DIR / "wake_refs"
 WAKE_REF_DIR.mkdir(parents=True, exist_ok=True)
 
@@ -16,6 +15,8 @@ LGY_CONFIG_FILE = WORKSPACE_DIR / "lgy.json"
 
 DEFAULT_LGY_CONFIG = {
     "discord_token": "",
+    "telegram_token": "",
+    "telegram_allowed_user_ids": "",
     "session_scopes": [],
     "allowed_user_ids": "",
     # user_id (str) -> registered word, one per person (see EnrollmentManager._commit_enrollment).
@@ -74,6 +75,7 @@ logger = init_logger(WORKSPACE_DIR)
 
 
 DISCORD_TOKEN = bot_settings.get("discord_token", "")
+TELEGRAM_TOKEN = bot_settings.get("telegram_token", "")
 
 
 def _parse_session_scopes(raw_scopes) -> dict:
@@ -97,6 +99,7 @@ def _parse_session_scopes(raw_scopes) -> dict:
 
 SESSION_SCOPES = _parse_session_scopes(bot_settings.get("session_scopes"))
 ALLOWED_IDS = set(int(x) for x in bot_settings.get("allowed_user_ids", "").split(",") if x.strip())
+TELEGRAM_ALLOWED_IDS = set(int(x) for x in bot_settings.get("telegram_allowed_user_ids", "").split(",") if x.strip())
 TTS_VOICE = bot_settings.get("tts_voice", "ko-KR-SunHiNeural")
 
 
@@ -120,6 +123,7 @@ TMP_VOICE_DIR.mkdir(parents=True, exist_ok=True)
 
 MAX_EMBED_LEN = 1900
 STREAM_RATE_LIMIT_SEC = 0.5
+APPROVAL_TIMEOUT_SEC = 1800
 PERSISTENT_FILE = DATA_DIR / "persistent_tools.json"
 SESSION_FILE = DATA_DIR / "sessions.json"
 
@@ -136,5 +140,6 @@ AGY_BIN = os.getenv("AGY_BIN_PATH", str(Path.home() / ".local/bin/agy"))
 session_manager = SessionManager(DATA_DIR)
 
 
-def allowed(user_id: int) -> bool:
-    return not ALLOWED_IDS or user_id in ALLOWED_IDS
+def allowed(user_id: int, platform: str = "discord") -> bool:
+    ids = TELEGRAM_ALLOWED_IDS if platform == "telegram" else ALLOWED_IDS
+    return not ids or user_id in ids

package/src/core/agy_runner.py

@@ -118,10 +118,10 @@ async def run_agy(
         for attempt in range(max_retries):
             try:
                 env = os.environ.copy()
-                env["AGY_DISCORD_BOT"] = "1"
+                env["LGY_APPROVAL_HOOK"] = "1"
                 env["PYTHONUNBUFFERED"] = "1"
                 if thread_id:
-                    env["DISCORD_THREAD_ID"] = thread_id
+                    env["LGY_THREAD_ID"] = thread_id
 
                 libstdbuf_path = _find_libstdbuf()  # works around agy's output-truncation bug
                 if libstdbuf_path:
@@ -206,7 +206,7 @@ async def run_agy(
                 gather_task = asyncio.create_task(_gather_pipes())
                 wait_task = asyncio.create_task(proc.wait())
 
-                # Slices let the timeout pause during a pending Discord approval (up to 3600s).
+                # Slices let the timeout pause during a pending tool approval (up to 3600s).
                 from config import session_manager as _sm
 
                 poll_slice = 5.0

package/src/core/session_manager.py

@@ -1,4 +1,5 @@
 import asyncio
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 
@@ -79,6 +80,30 @@ class SessionManager:
     def get_active_queue_keys(self) -> list:
         return list(self.active_queues.keys())
 
+    def cleanup_stale_sessions(self, pending_max_age_days: int = 7) -> int:
+        """Only ever removes 'pending' sessions (started with /new but never actually used - no real conversation attached) older than pending_max_age_days, or with no created_at at all (pre-dates that field, safe to treat as stale). 'active' sessions are NEVER removed by age: Discord threads must stay resumable indefinitely, and Telegram's 1-chat-1-session model already overwrites its one entry on each /new, so there's nothing to accumulate there either. Returns how many were removed."""
+        now = datetime.now()
+        to_remove = []
+        for thread_id, session in self.sessions.items():
+            if session.get("status") != "pending":
+                continue
+            created_at_str = session.get("created_at")
+            if not created_at_str:
+                to_remove.append(thread_id)
+                continue
+            try:
+                age_days = (now - datetime.fromisoformat(created_at_str)).days
+            except ValueError:
+                continue
+            if age_days > pending_max_age_days:
+                to_remove.append(thread_id)
+
+        for thread_id in to_remove:
+            self.sessions.pop(thread_id, None)
+        if to_remove:
+            self.save_sessions()
+        return len(to_remove)
+
     def get_tts_task(self, thread_id: str) -> asyncio.Task | None:
         return self.active_tts_tasks.get(str(thread_id))
 

package/src/handlers/message_router.py

@@ -1,16 +1,13 @@
-import discord
-
 from config import allowed
 from handlers.thread_reply import handle_thread_reply
+from messengers.base import MessengerAdapter
 
 
-async def handle_message(bot, message: discord.Message):
-    if message.type not in (discord.MessageType.default, discord.MessageType.reply):
-        return
-    if message.author.bot:
+async def handle_message(bot, raw_event, adapter: MessengerAdapter):
+    incoming = adapter.to_incoming_message(raw_event)
+    if incoming is None:
         return
-    if not allowed(message.author.id):
+    if not allowed(incoming.author_id, incoming.platform):
         return
 
-    if isinstance(message.channel, discord.Thread):
-        await handle_thread_reply(bot, message)
+    await handle_thread_reply(bot, incoming)

package/src/handlers/thread_reply.py

@@ -2,10 +2,9 @@ import asyncio
 import time
 from datetime import datetime
 
-import discord
-
 from config import session_manager
-from messengers.registry import get_adapter
+from messengers.base import IncomingMessage
+from messengers.registry import get_adapter_for_platform
 from services.response import render_thought_process, send_agy_response
 from services.streaming import stream_thinking_latest
 from utils.utils import (
@@ -20,10 +19,15 @@ from utils.utils import (
 )
 
 
-async def handle_approval_reply(
-    message: discord.Message, thread: discord.Thread, session: dict, content: str, pa
-) -> bool:
-    adapter = get_adapter()
+async def handle_approval_reply(incoming: IncomingMessage, session: dict, content: str, pa) -> bool:
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
+
+    if session_manager.get_pending_approval_type_by_conv(incoming.conversation_id) == "ask_question":
+        pa.set_result(content)
+        await adapter.send_message(thread, f'✅ *Answer Received (Write in): "{content}"*')
+        return True
+
     if content.lower() in ("yes", "y", "allow", "승인"):
         pa.set_result("allow")
         await adapter.send_message(thread, f'✅ *Answer Received (Write in): "{content}"*')
@@ -38,38 +42,42 @@ async def handle_approval_reply(
         return True
     elif content.lower() in ("clear", "reset"):
         await adapter.send_message(thread, "🧹 Conversation context cleared.")
-        old_sess = session_manager.remove_session(str(thread.id))
+        old_sess = session_manager.remove_session(incoming.conversation_id)
         if old_sess:
-            session_manager.set_session(str(thread.id), old_sess)
+            session_manager.set_session(incoming.conversation_id, old_sess)
         return True
     return False
 
 
 async def handle_pending_session(
-    bot, thread: discord.Thread, session: dict, agy_content: str, content: str, image_paths: list
+    bot, incoming: IncomingMessage, session: dict, agy_content: str, content: str, image_paths: list
 ):
-    adapter = get_adapter()
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
     try:
         async with adapter.typing(thread):
             ctx = {"status_msg": None}
             start_time = time.time()
             queue = asyncio.Queue()
-            session_manager.register_queue(str(thread.id), queue)
-            stream_task = asyncio.create_task(stream_thinking_latest(bot, thread, context_dict=ctx, queue=queue))
+            session_manager.register_queue(incoming.conversation_id, queue)
+            stream_task = asyncio.create_task(
+                stream_thinking_latest(bot, thread, incoming.conversation_id, context_dict=ctx, queue=queue)
+            )
 
             cwd = session.get("cwd")
             model = session.get("model")
             result_text, new_conv_id = await agy_new_conversation(
-                agy_content, model=model, stream_queue=queue, thread_id=str(thread.id), cwd=cwd
+                agy_content, model=model, stream_queue=queue, thread_id=incoming.conversation_id, cwd=cwd
             )
 
             await queue.put(("__END__", True))
             await stream_task
 
             response_text = result_text
-            new_title = await generate_thread_title(content, response_text)
-            await adapter.rename_conversation(thread, new_title)
-            await update_agy_conversation_title(new_conv_id, new_title)
+            if adapter.supports_renaming:
+                new_title = await generate_thread_title(content, response_text)
+                await adapter.rename_conversation(thread, new_title)
+                await update_agy_conversation_title(new_conv_id, new_title)
 
             response_text = await render_thought_process(new_conv_id, ctx, response_text, thread)
 
@@ -84,22 +92,25 @@ async def handle_pending_session(
 
 
 async def handle_existing_session(
-    bot, thread: discord.Thread, session: dict, conv_id: str, agy_content: str, image_paths: list
+    bot, incoming: IncomingMessage, session: dict, conv_id: str, agy_content: str, image_paths: list
 ):
-    adapter = get_adapter()
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
     try:
         async with adapter.typing(thread):
             ctx = {"status_msg": None}
             start_time = time.time()
             queue = asyncio.Queue()
-            session_manager.register_queue(str(thread.id), queue)
-            stream_task = asyncio.create_task(stream_thinking_latest(bot, thread, context_dict=ctx, queue=queue))
+            session_manager.register_queue(incoming.conversation_id, queue)
+            stream_task = asyncio.create_task(
+                stream_thinking_latest(bot, thread, incoming.conversation_id, context_dict=ctx, queue=queue)
+            )
             result_text = await agy_send_message(
                 conv_id,
                 agy_content,
                 model=session.get("model"),
                 stream_queue=queue,
-                thread_id=str(thread.id),
+                thread_id=incoming.conversation_id,
                 cwd=session.get("cwd"),
             )
             await queue.put(("__END__", True))
@@ -112,14 +123,14 @@ async def handle_existing_session(
         cleanup_images(image_paths)
 
 
-async def handle_thread_reply(bot, message: discord.Message):
-    thread = message.channel
-    session = session_manager.get_session(str(thread.id))
+async def handle_thread_reply(bot, incoming: IncomingMessage):
+    session = session_manager.get_session(incoming.conversation_id)
     if not session:
         return
 
-    adapter = get_adapter()
-    content = message.content.strip()
+    adapter = get_adapter_for_platform(incoming.platform)
+    thread = incoming.conversation_ref
+    content = incoming.content.strip()
     if content.startswith("/new"):
         await adapter.send_message(
             thread,
@@ -127,10 +138,11 @@ async def handle_thread_reply(bot, message: discord.Message):
         )
         return
 
-    for att in message.attachments:
+    for att in incoming.attachments:
         ct = att.content_type or ""
         if "audio" in ct or att.filename.endswith((".ogg", ".mp3", ".m4a", ".wav")):
-            await message.add_reaction("🎤")
+            if incoming.add_reaction:
+                await incoming.add_reaction("🎤")
             audio_bytes = await att.read()
             text = await stt(audio_bytes)
             if text:
@@ -138,9 +150,10 @@ async def handle_thread_reply(bot, message: discord.Message):
                 await adapter.send_message(thread, f'🎤 *Speech Recognized: "{text}"*')
             break
 
-    image_paths = await handle_image_attachments(message)
+    image_paths = await handle_image_attachments(incoming.attachments)
     if image_paths:
-        await message.add_reaction("📎")
+        if incoming.add_reaction:
+            await incoming.add_reaction("📎")
         await adapter.send_message(thread, f"📎 *{len(image_paths)} file(s) attached*")
 
     if not content and not image_paths:
@@ -153,16 +166,31 @@ async def handle_thread_reply(bot, message: discord.Message):
     pa = session_manager.get_pending_approval_by_conv(conv_id) if conv_id else None
 
     if conv_id and pa and not pa.done():
-        handled = await handle_approval_reply(message, thread, session, content, pa)
+        handled = await handle_approval_reply(incoming, session, content, pa)
         if handled:
             return
 
+    has_pending_approval = bool(conv_id and pa and not pa.done())
+    if session_manager.get_queue(incoming.conversation_id) is not None and not has_pending_approval:
+        from core.agy_runner import stop_active_process
+
+        stop_active_process(incoming.conversation_id)
+        session_manager.remove_queue(incoming.conversation_id)
+
+        prev_session = session_manager.get_session(incoming.conversation_id)
+        if prev_session:
+            session_manager.set_session(
+                incoming.conversation_id, {**prev_session, "status": "pending", "conversation_id": None}
+            )
+            session = session_manager.get_session(incoming.conversation_id)
+            conv_id = None
+
     if not conv_id:
         if session.get("status") == "pending":
-            await handle_pending_session(bot, thread, session, agy_content, content, image_paths)
+            await handle_pending_session(bot, incoming, session, agy_content, content, image_paths)
             return
         else:
             await adapter.send_message(thread, "⚠️ Session ID not found. Start a new session with `/new`.")
             return
 
-    await handle_existing_session(bot, thread, session, conv_id, agy_content, image_paths)
+    await handle_existing_session(bot, incoming, session, conv_id, agy_content, image_paths)