linkgravity 1.0.0

package/src/handlers/message_router.py

@@ -0,0 +1,16 @@
+import discord
+
+from config import allowed
+from handlers.thread_reply import handle_thread_reply
+
+
+async def handle_message(bot, message: discord.Message):
+    if message.type not in (discord.MessageType.default, discord.MessageType.reply):
+        return
+    if message.author.bot:
+        return
+    if not allowed(message.author.id):
+        return
+
+    if isinstance(message.channel, discord.Thread):
+        await handle_thread_reply(bot, message)

package/src/handlers/thread_reply.py

@@ -0,0 +1,165 @@
+import asyncio
+import time
+from datetime import datetime
+
+import discord
+
+from config import session_manager
+from messengers.registry import get_adapter
+from services.response import render_thought_process, send_agy_response
+from services.streaming import stream_thinking_latest
+from utils.utils import (
+    agy_new_conversation,
+    agy_send_message,
+    build_content_with_images,
+    cleanup_images,
+    generate_thread_title,
+    handle_image_attachments,
+    stt,
+)
+
+
+async def handle_approval_reply(
+    message: discord.Message, thread: discord.Thread, session: dict, content: str, pa
+) -> bool:
+    adapter = get_adapter()
+    if content.lower() in ("yes", "y", "allow", "승인"):
+        pa.set_result("allow")
+        await adapter.send_message(thread, f'✅ *Answer Received (Write in): "{content}"*')
+        return True
+    elif content.lower() in ("c", "cancel"):
+        pa.set_result("allow")
+        await adapter.send_message(thread, "✅ *Text Approval Received*")
+        return True
+    elif content.lower() in ("no", "n", "reject", "거절"):
+        pa.set_result("reject")
+        await adapter.send_message(thread, "❌ *Text Rejection Received*")
+        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))
+        if old_sess:
+            session_manager.set_session(str(thread.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
+):
+    adapter = get_adapter()
+    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))
+
+            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
+            )
+
+            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)
+
+            response_text = await render_thought_process(new_conv_id, ctx, response_text, thread)
+
+            session["conversation_id"] = new_conv_id
+            session["created_at"] = datetime.now().isoformat()
+            session["status"] = "active"
+            session_manager.save_sessions()
+
+            await send_agy_response(thread, response_text, session, ctx, start_time, new_conv_id)
+    finally:
+        cleanup_images(image_paths)
+
+
+async def handle_existing_session(
+    bot, thread: discord.Thread, session: dict, conv_id: str, agy_content: str, image_paths: list
+):
+    adapter = get_adapter()
+    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))
+            result_text = await agy_send_message(
+                conv_id,
+                agy_content,
+                model=session.get("model"),
+                stream_queue=queue,
+                thread_id=str(thread.id),
+                cwd=session.get("cwd"),
+            )
+            await queue.put(("__END__", True))
+            await stream_task
+
+            response_text = result_text
+            response_text = await render_thought_process(conv_id, ctx, response_text, thread)
+            await send_agy_response(thread, response_text, session, ctx, start_time, conv_id)
+    finally:
+        cleanup_images(image_paths)
+
+
+async def handle_thread_reply(bot, message: discord.Message):
+    thread = message.channel
+    session = session_manager.get_session(str(thread.id))
+    if not session:
+        return
+
+    adapter = get_adapter()
+    content = message.content.strip()
+    if content.startswith("/new"):
+        await adapter.send_message(thread, 
+            "To start a new session, please use the `/new` slash command (not typed as text) - it works from inside a thread too and will open the new one in the right place."
+        )
+        return
+
+    for att in message.attachments:
+        ct = att.content_type or ""
+        if "audio" in ct or att.filename.endswith((".ogg", ".mp3", ".m4a", ".wav")):
+            await message.add_reaction("🎤")
+            audio_bytes = await att.read()
+            text = await stt(audio_bytes)
+            if text:
+                content = text
+                await adapter.send_message(thread, f'🎤 *Speech Recognized: "{text}"*')
+            break
+
+    image_paths = await handle_image_attachments(message)
+    if image_paths:
+        await message.add_reaction("📎")
+        await adapter.send_message(thread, f"📎 *{len(image_paths)} file(s) attached*")
+
+    if not content and not image_paths:
+        return
+    if not content:
+        content = "Analyze this attachment"
+
+    agy_content = build_content_with_images(content, image_paths)
+    conv_id = session.get("conversation_id")
+    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)
+        if handled:
+            return
+
+    if not conv_id:
+        if session.get("status") == "pending":
+            await handle_pending_session(bot, thread, 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)

package/src/main.py

@@ -0,0 +1,313 @@
+import asyncio
+import atexit
+import os
+import subprocess
+import sys
+from functools import partial
+
+import discord
+from discord.ext import commands
+
+from api import server
+from config import (
+    DISCORD_TOKEN,
+    SESSION_SCOPES,
+    logger,
+    session_manager,
+)
+from handlers.message_router import handle_message
+from services.response import send_agy_response
+from services.streaming import stream_thinking_latest
+from utils.utils import (
+    agy_new_conversation,
+    agy_send_message,
+    stt,
+    tts,
+)
+
+voice_process = None
+_voice_shutting_down = False
+_voice_restart_timestamps = []  # epoch seconds of recent auto-restarts, for the backoff/giveup check below
+
+VOICE_SERVICE_HEALTH_URL = "http://localhost:18081/health"
+VOICE_SERVICE_READY_TIMEOUT_SEC = 20
+
+
+async def _wait_for_voice_service_ready():
+    import aiohttp
+
+    deadline = asyncio.get_event_loop().time() + VOICE_SERVICE_READY_TIMEOUT_SEC
+    async with aiohttp.ClientSession() as session:
+        while asyncio.get_event_loop().time() < deadline:
+            try:
+                async with session.get(VOICE_SERVICE_HEALTH_URL, timeout=aiohttp.ClientTimeout(total=2)) as resp:
+                    if resp.status == 200:
+                        data = await resp.json()
+                        if data.get("ready"):
+                            logger.info("🎤 Voice service is online and ready.")
+                            return
+            except Exception:
+                pass
+            await asyncio.sleep(0.5)
+    logger.warning(
+        f"Voice service did not report ready within {VOICE_SERVICE_READY_TIMEOUT_SEC}s - "
+        "/join may fail until it finishes starting."
+    )
+
+
+STATUS_TEXT_BY_KEYWORDS = [
+    (("run_command",), "🖥️ Running command..."),
+    (("file", "list"), "🔍 Analyzing files..."),
+    (("search", "web"), "🌐 Searching web..."),
+    (("replace", "write"), "✍️ Writing code..."),
+    (("ask_question",), "❓ Waiting for input..."),
+]
+
+
+def _status_text_for_tool(tool_name: str) -> str:
+    for keywords, text in STATUS_TEXT_BY_KEYWORDS:
+        if any(keyword in tool_name for keyword in keywords):
+            return text
+    return f"⚙️ Running {tool_name}..."
+
+
+intents = discord.Intents.default()
+intents.message_content = True
+intents.voice_states = True
+bot = commands.Bot(command_prefix="!", intents=intents)
+
+
+async def status_updater_task():
+    await bot.wait_until_ready()
+    logger.debug("status_updater_task started")
+    try:
+        last_status = ""
+        while True:
+            await asyncio.sleep(2)
+
+            full_status = ""
+            if not session_manager.has_active_queues():
+                full_status = "🟢 Idle"
+            else:
+                first_t_id = session_manager.get_active_queue_keys()[0]
+                sess = session_manager.get_session(first_t_id) or {}
+                tool_name = sess.get("current_tool")
+                full_status = _status_text_for_tool(tool_name) if tool_name else "🧠 Thinking..."
+
+            if full_status != last_status:
+                logger.debug(f"Status updating to: {full_status}")
+                try:
+                    await bot.change_presence(
+                        status=discord.Status.online,
+                        activity=discord.Activity(type=discord.ActivityType.playing, name=full_status),
+                    )
+                    last_status = full_status
+                except discord.HTTPException as e:
+                    logger.warning(f"Presence update rate-limited or failed: {e}")
+                except Exception as e:
+                    logger.warning(f"Presence update error: {e}")
+    except asyncio.CancelledError:
+        logger.debug("Status updater task was cancelled.")
+    except Exception as e:
+        logger.exception(f"FATAL ERROR IN STATUS UPDATER: {e}")
+
+
+def _spawn_voice_process(voice_dir: str) -> subprocess.Popen:
+    return subprocess.Popen(["node", "index.js"], cwd=voice_dir)
+
+
+async def _supervise_voice_process(voice_dir: str):
+    """voice_process (voice-service/index.js) can die on its own - most
+    notably from the known upstream @discordjs/voice DAVE decrypt bug
+    (discordjs/discord.js#11419), which can throw synchronously out of
+    an event handler with nothing upstream to catch it. Without this,
+    that single crash would leave every voice feature (wake word, STT,
+    TTS) dead until someone manually restarts the whole bot.
+
+    Polls every 1s so a crash gets noticed and a restart kicked off
+    almost immediately - the "5 crashes in 5 minutes" check below is
+    NOT a claim that 5 minutes of intermittent breakage is acceptable;
+    it only exists to stop a genuine crash-loop (missing node_modules,
+    a port conflict, etc.) from burning CPU forever. Anyone mid-
+    recording when Node dies gets told immediately via
+    VoiceCog.handle_voice_service_down(), rather than finding out
+    whenever a stale request to Node eventually times out.
+    """
+    global voice_process
+    while True:
+        await asyncio.sleep(1)
+        if _voice_shutting_down:
+            return
+        if voice_process is None or voice_process.poll() is None:
+            continue  # still running (or never started) - nothing to do
+
+        exit_code = voice_process.poll()
+        logger.warning(f"🎤 Voice service exited unexpectedly (code {exit_code}). Attempting to restart it...")
+
+        # Notify anyone mid-recording before attempting the restart, not after.
+        voice_cog = bot.get_cog("VoiceCog")
+        if voice_cog:
+            try:
+                await voice_cog.handle_voice_service_down()
+            except Exception as e:
+                logger.error(f"Error notifying users of voice service outage: {e}")
+
+        now = asyncio.get_event_loop().time()
+        _voice_restart_timestamps.append(now)
+        while _voice_restart_timestamps and now - _voice_restart_timestamps[0] > 300:
+            _voice_restart_timestamps.pop(0)
+
+        if len(_voice_restart_timestamps) > 5:
+            logger.error(
+                "🎤 Voice service has crashed 5+ times in the last 5 minutes - giving up on auto-restart "
+                "to avoid a crash loop. Check `lgy logs` for the underlying error, fix it, then run "
+                "`lgy restart`."
+            )
+            return
+
+        try:
+            voice_process = _spawn_voice_process(voice_dir)
+            asyncio.create_task(_wait_for_voice_service_ready())
+        except Exception as e:
+            logger.error(f"Failed to restart voice service: {e}")
+
+
+@bot.event
+async def on_ready():
+    logger.info(f"✅ Bot is fully online and ready! Logged in as {bot.user}")
+
+
+@bot.event
+async def setup_hook():
+    await bot.tree.sync()
+    logger.info("Slash commands synced.")
+
+    asyncio.create_task(server.setup_webhook_server(bot))
+
+    global voice_process
+    try:
+        voice_dir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "voice-service")
+        logger.debug(f"Spawning Node.js process at: {voice_dir}")
+        if os.path.exists(os.path.join(voice_dir, "index.js")):
+            if not os.path.isdir(os.path.join(voice_dir, "node_modules")):
+                logger.error(
+                    "voice-service/node_modules is missing - its dependencies were never installed "
+                    "(or got wiped, e.g. by replacing project files without re-running `npm install`). "
+                    "Voice features will not work until you run `npm install` in the project root "
+                    "and restart the bot."
+                )
+            voice_process = _spawn_voice_process(voice_dir)
+            logger.info("🎤 Voice service starting, waiting for it to come online...")
+            asyncio.create_task(_wait_for_voice_service_ready())
+            asyncio.create_task(_supervise_voice_process(voice_dir))
+
+            def cleanup_voice():
+                global _voice_shutting_down
+                _voice_shutting_down = True
+                if voice_process and voice_process.poll() is None:
+                    logger.debug("Zombie prevention: Terminating child Node.js process as Python exits...")
+                    voice_process.terminate()
+                    try:
+                        voice_process.wait(timeout=3)
+                    except subprocess.TimeoutExpired:
+                        voice_process.kill()
+
+            atexit.register(cleanup_voice)
+        else:
+            logger.warning("Voice service (index.js) not found. Skipping auto-start.")
+    except Exception as e:
+        logger.error(f"Failed to auto-start voice service: {e}")
+
+    def _handle_task_exception(loop, context):
+        exc = context.get("exception")
+        if exc:
+            logger.opt(exception=exc).error(f"Unhandled asyncio task exception: {context.get('message', '')}")
+        else:
+            logger.error(f"Unhandled asyncio context: {context}")
+
+    asyncio.get_event_loop().set_exception_handler(_handle_task_exception)
+
+    logger.debug("Launching status_updater_task...")
+    asyncio.create_task(status_updater_task())
+    logger.debug("status_updater_task dispatched")
+
+
+@bot.event
+async def on_error(event_method: str, *args, **kwargs):
+    logger.exception(f"Unhandled exception in Discord event: {event_method}")
+    exc_type, exc_value, _ = sys.exc_info()
+    if exc_value is None:
+        return
+
+    error_msg = "⚠️ **An internal bot error has occurred.** Please contact the developer or check the server logs."
+
+    if event_method == "on_message":
+        if args and isinstance(args[0], discord.Message):
+            message = args[0]
+            try:
+                await message.reply(error_msg)
+            except Exception:
+                pass
+
+
+@bot.event
+async def on_application_command_error(interaction, error):
+    logger.exception(f"Slash command error: {error}")
+    error_msg = "⚠️ **An error occurred while processing the command.** 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
+
+
+@bot.event
+async def on_message(message: discord.Message):
+    await handle_message(bot, message)
+
+
+async def main():
+    if not DISCORD_TOKEN or not SESSION_SCOPES:
+        logger.critical("Missing DISCORD_TOKEN, or no server/channel configured (session_scopes) - run `lgy setup`")
+        return
+
+    discord.utils.setup_logging()
+
+    from messengers.discord_adapter import DiscordAdapter
+    from messengers.registry import set_adapter
+
+    set_adapter(DiscordAdapter(bot))
+
+    async with bot:
+        from cogs.voice_cog import VoiceCog
+        from config import bot_settings, save_bot_settings
+
+        await bot.add_cog(
+            VoiceCog(
+                bot=bot,
+                stt=stt,
+                tts=tts,
+                send_agy_response=send_agy_response,
+                agy_send=agy_send_message,
+                stream_thinking_latest=partial(stream_thinking_latest, bot),
+                agy_start_session=agy_new_conversation,
+                session_manager=session_manager,
+                bot_settings=bot_settings,
+                save_bot_settings=save_bot_settings,
+                logger=logger,
+            )
+        )
+
+        from cogs.general_cog import GeneralCog
+
+        await bot.add_cog(GeneralCog(bot=bot))
+        await bot.start(DISCORD_TOKEN)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass

package/src/messengers/base.py

@@ -0,0 +1,105 @@
+"""Core messenger interface. Every backend (Discord now, Slack/Telegram
+later) implements MessengerAdapter; business logic never touches
+platform SDK types directly.
+
+Futures for approval/question prompts are owned by business logic, not
+the adapter - the same future can also be resolved by a typed reply,
+voice, or /stop, not just a button. Voice is deliberately not part of
+this interface; see VoiceCapable.
+"""
+
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any, Protocol, runtime_checkable
+
+
+@dataclass
+class ScopeOption:
+    """kind: "commands" or "tools" - which persistent allowlist scope belongs to."""
+
+    kind: str
+    scope: str
+
+
+@dataclass
+class ToolApprovalOutcome:
+    decision: str  # "allow" | "reject"
+    scope: ScopeOption | None = None
+
+
+class PromptHandle(ABC):
+    outcome: ToolApprovalOutcome | None = None
+
+    @abstractmethod
+    async def send(self, conversation_ref: Any) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def finalize(self) -> None:
+        raise NotImplementedError
+
+
+class MessengerAdapter(ABC):
+    platform_name: str = "unknown"
+
+    @abstractmethod
+    async def send_message(self, conversation_ref: Any, text: str) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def edit_message(self, message_ref: Any, text: str) -> bool:
+        """Returns False if the message is gone - caller should send a new one instead."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def send_files(self, conversation_ref: Any, file_paths: list[str]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def resolve_conversation(self, conversation_id: str) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def start_conversation(self, origin_ref: Any, title: str) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def rename_conversation(self, conversation_ref: Any, title: str) -> None:
+        raise NotImplementedError
+
+    @asynccontextmanager
+    async def typing(self, conversation_ref: Any):
+        yield
+
+    @abstractmethod
+    def create_tool_approval_prompt(
+        self,
+        decision_future,
+        title: str,
+        body: str,
+        scope_options: list[ScopeOption],
+    ) -> PromptHandle:
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_question_prompt(
+        self,
+        answer_future,
+        question: str,
+        options: list[str],
+        multi_select: bool = False,
+        allow_write_in: bool = True,
+    ) -> PromptHandle:
+        raise NotImplementedError
+
+    @property
+    def supports_voice(self) -> bool:
+        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: ...