linkgravity 1.0.0

package/src/api/ui_routes.py

@@ -0,0 +1,340 @@
+import asyncio
+import json
+import re
+import shlex
+import uuid
+
+from aiohttp import web
+
+from config import MAX_EMBED_LEN, logger, session_manager
+from messengers.base import ScopeOption
+from messengers.registry import get_adapter
+
+
+def is_tool_allowed(tool_name, tool_input):
+    from api.server import is_tool_allowed as is_tool_allowed_orig
+
+    return is_tool_allowed_orig(tool_name, tool_input)
+
+
+async def send_ordered(target_thread_id, send_coro_factory):
+    """Routes through the same per-conversation stream queue as the answer
+    text, so tool-call messages can't arrive out of order. Falls back to
+    a direct call if no stream is registered."""
+    q = session_manager.get_queue(target_thread_id) if target_thread_id else None
+    if not q:
+        return await send_coro_factory()
+
+    from config import STREAM_RATE_LIMIT_SEC
+
+    await asyncio.sleep(STREAM_RATE_LIMIT_SEC)
+
+    done = asyncio.get_running_loop().create_future()
+    q.put_nowait(("__RUN_ORDERED__", send_coro_factory, done))
+    return await done
+
+
+def build_permission_overrides(tool_name, tool_input):
+    """Builds the PreToolUse `permissionOverrides` output field for an
+    approved call. Print mode soft-denies a tool unless a matching allow
+    rule exists even when the hook says "allow"; returning
+    "command(<CommandLine>)" supplies that rule for this one call."""
+    if tool_name == "run_command" and isinstance(tool_input, dict):
+        command_line = tool_input.get("CommandLine")
+        if command_line:
+            return [f"command({command_line})"]
+    return None
+
+
+def allow_response(tool_name, tool_input):
+    body = {"decision": "allow"}
+    overrides = build_permission_overrides(tool_name, tool_input)
+    if overrides:
+        body["permissionOverrides"] = overrides
+    return web.json_response(body)
+
+
+def _persist_scope_if_granted(prompt_handle):
+    """If the prompt was resolved via a persistent-allow button, records
+    that scope. Scope persistence is business logic, so it lives here
+    rather than inside the adapter's button callback - a future resolved
+    by a non-UI path (typed reply, voice) simply has no outcome/scope."""
+    outcome = prompt_handle.outcome
+    if outcome and outcome.decision == "allow" and outcome.scope:
+        kind, scope = outcome.scope.kind, outcome.scope.scope
+        if scope not in session_manager.persistent_allowed[kind]:
+            session_manager.persistent_allowed[kind].append(scope)
+            session_manager.save_persistent()
+
+
+def _clean_inline(text: str) -> str:
+    return re.sub(r"[*#_`]", "", text).replace("\n", " ").strip()
+
+
+async def handle_approve_request(request):
+    # Tracks approval_keys registered this request so the exception handler can clean them up.
+    registered_approval_keys = []
+    try:
+        data = await request.json()
+        conv_id = data.get("conversation_id")
+        tool_name = data.get("tool_name")
+        tool_input = data.get("tool_input")
+        payload_thread_id = data.get("thread_id")
+
+        # DEBUG-only (see logger.py's LOG_LEVEL). Silent by default.
+        logger.debug(f"[APPROVE HOOK] tool_name={tool_name!r} conv_id={conv_id!r} tool_input={tool_input!r}")
+
+        adapter = get_adapter()
+
+        target_thread = None
+        target_thread_id = None
+        for thread_id_str, sess in session_manager.get_all_sessions().items():
+            if sess.get("conversation_id") == conv_id:
+                target_thread = adapter.resolve_conversation(thread_id_str)
+                target_thread_id = thread_id_str
+                break
+
+        if not target_thread and payload_thread_id:
+            resolved_channel = adapter.resolve_conversation(payload_thread_id)
+            if resolved_channel:
+                target_thread = resolved_channel
+                target_thread_id = payload_thread_id
+                if session_manager.get_session(payload_thread_id):
+                    session_manager.update_session(payload_thread_id, "conversation_id", conv_id)
+                    session_manager.update_session(payload_thread_id, "status", "active")
+
+        if not target_thread:
+            for thread_id_str, sess in reversed(list(session_manager.get_all_sessions().items())):
+                if sess.get("status") == "pending":
+                    target_thread = adapter.resolve_conversation(thread_id_str)
+                    session_manager.update_session(thread_id_str, "conversation_id", conv_id)
+                    session_manager.update_session(thread_id_str, "status", "active")
+                    target_thread_id = thread_id_str
+                    break
+
+        if target_thread_id and session_manager.get_session(target_thread_id):
+            session_manager.update_session(target_thread_id, "current_tool", tool_name)
+
+        if "ask_question" in tool_name:
+            if not target_thread:
+                return web.json_response({"decision": "deny", "reason": "No target thread found."})
+
+            questions = tool_input.get("questions", [])
+            if not questions:
+                return web.json_response({"decision": "deny", "reason": "No questions provided."})
+
+            q_data = questions[0]
+            question_text = _clean_inline(q_data.get("question", "No question provided."))
+            options = [(_clean_inline(str(opt)) or "Option")[:80] for opt in q_data.get("options", [])]
+            is_multi_select = q_data.get("is_multi_select", False)
+
+            future = asyncio.get_running_loop().create_future()
+            approval_key = f"{conv_id}:{uuid.uuid4().hex}"
+            session_manager.set_pending_approval(approval_key, future, "ask_question", conv_id=conv_id)
+            registered_approval_keys.append(approval_key)
+
+            prompt = adapter.create_question_prompt(
+                future, question_text, options, multi_select=is_multi_select, allow_write_in=True
+            )
+            await send_ordered(target_thread_id, lambda: prompt.send(target_thread))
+
+            chosen_opt = await future
+            session_manager.clear_pending_approval(approval_key)
+            await prompt.finalize()
+
+            return web.json_response(
+                {"decision": "deny", "reason": f"User selected via Discord button: [{chosen_opt}]"}
+            )
+
+        from approval.command_parser import parse_shell_commands
+        from approval.tool_formatter import format_bash_display, format_tool_display
+
+        if "run_command" in tool_name:
+            cmd = tool_input.get("CommandLine", "")
+            sub_cmds = parse_shell_commands(cmd)
+            tool_msg_text, desc_json, _ = format_bash_display(sub_cmds[0] if sub_cmds else cmd)
+            tool_msg_formatted = f"```text\n{tool_msg_text}\n```{desc_json}"
+        else:
+            sub_cmds = [None]
+            tool_msg_text, desc_json, view_tool_input = format_tool_display(tool_name, tool_input)
+            tool_msg_formatted = f"```text\n{tool_msg_text}\n```{desc_json}"
+
+        if "run_command" in tool_name:
+            prompted = False
+            for sub_cmd in sub_cmds:
+                if not sub_cmd:
+                    continue
+
+                is_auto_allowed = False
+                if "\n" not in sub_cmd and "|" not in sub_cmd:
+                    try:
+                        tokens = shlex.split(sub_cmd)
+                        for scope in session_manager.persistent_allowed.get("commands", []):
+                            scope_tokens = shlex.split(scope)
+                            if len(scope_tokens) <= len(tokens) and tokens[: len(scope_tokens)] == scope_tokens:
+                                is_auto_allowed = True
+                                break
+                    except ValueError:
+                        pass
+                elif is_tool_allowed(tool_name, {"CommandLine": sub_cmd}) or (
+                    conv_id in session_manager.session_allowed_tools
+                    and tool_name in session_manager.session_allowed_tools[conv_id]
+                ):
+                    is_auto_allowed = True
+
+                if is_auto_allowed:
+                    continue
+
+                prompted = True
+
+                prompt_desc = f"**🎯 Requesting permission for:**\n```bash\n{sub_cmd}\n```\n"
+                if sub_cmd.strip() != cmd.strip():
+                    prompt_desc += f"**📜 Full command context:**\n```bash\n{cmd}\n```"
+                prompt_desc += (
+                    f"\n**🔧 Tool Execution Detail:**\n```json\n"
+                    f"{json.dumps(tool_input, indent=2, ensure_ascii=False)[:1000]}\n```"
+                )
+
+                # Persistent-allow options: expanding prefixes of the sub-command's tokens.
+                scope_options = []
+                try:
+                    tokens = shlex.split(sub_cmd)
+                except ValueError:
+                    tokens = [sub_cmd]
+                current_prefix = []
+                for t in tokens[:3]:
+                    current_prefix.append(t)
+                    scope_options.append(ScopeOption(kind="commands", scope=" ".join(current_prefix)))
+
+                approval_key = f"{conv_id}:{uuid.uuid4().hex}"
+                future = asyncio.get_running_loop().create_future()
+                session_manager.set_pending_approval(approval_key, future, conv_id=conv_id)
+                registered_approval_keys.append(approval_key)
+
+                prompt = adapter.create_tool_approval_prompt(
+                    future, "⚠️ Tool Execution Approval Required", prompt_desc, scope_options
+                )
+
+                sub_cmd_display, sub_cmd_desc, _ = format_bash_display(sub_cmd)
+                sub_cmd_formatted = f"```text\n{sub_cmd_display}\n```{sub_cmd_desc}"
+
+                async def _send_bash_prompt(sub_cmd_formatted=sub_cmd_formatted, prompt=prompt):
+                    await adapter.send_message(target_thread, sub_cmd_formatted)
+                    return await prompt.send(target_thread)
+
+                await send_ordered(target_thread_id, _send_bash_prompt)
+
+                decision = await future
+                session_manager.clear_pending_approval(approval_key)
+                _persist_scope_if_granted(prompt)
+                await prompt.finalize()
+
+                if decision == "reject":
+                    return web.json_response({"decision": "reject"})
+
+            if target_thread and tool_msg_text and not prompted:
+                await send_ordered(target_thread_id, lambda: adapter.send_message(target_thread, tool_msg_formatted))
+
+            return allow_response(tool_name, tool_input)
+
+        else:
+            is_auto_allowed = False
+            if is_tool_allowed(tool_name, tool_input) or (
+                conv_id in session_manager.session_allowed_tools
+                and tool_name in session_manager.session_allowed_tools[conv_id]
+            ):
+                is_auto_allowed = True
+
+            if is_auto_allowed:
+                if target_thread and tool_msg_text:
+                    await send_ordered(
+                        target_thread_id, lambda: adapter.send_message(target_thread, tool_msg_formatted)
+                    )
+                return allow_response(tool_name, tool_input)
+
+            approval_key = f"{conv_id}:{uuid.uuid4().hex}"
+            future = asyncio.get_running_loop().create_future()
+            session_manager.set_pending_approval(approval_key, future, conv_id=conv_id)
+            registered_approval_keys.append(approval_key)
+
+            scope_options = [ScopeOption(kind="tools", scope=tool_name)]
+            prompt = adapter.create_tool_approval_prompt(
+                future, "⚠️ Tool Execution Approval Required", tool_msg_formatted, scope_options
+            )
+
+            async def _send_prompt():
+                await adapter.send_message(target_thread, tool_msg_formatted)
+                return await prompt.send(target_thread)
+
+            await send_ordered(target_thread_id, _send_prompt)
+
+            decision = await future
+            session_manager.clear_pending_approval(approval_key)
+            _persist_scope_if_granted(prompt)
+            await prompt.finalize()
+
+            if decision == "reject":
+                return web.json_response({"decision": "reject"})
+
+            return allow_response(tool_name, tool_input)
+
+    except Exception as e:
+        logger.exception(f"Error in handle_approve_request: {e}")
+        for key in registered_approval_keys:
+            session_manager.clear_pending_approval(key)
+        return web.json_response({"decision": "allow"})
+
+
+async def handle_mcp_ask(request):
+    try:
+        data = await request.json()
+        thread_id = data.get("thread_id")
+
+        question = _clean_inline(data.get("question", "No question provided."))
+        options = [(_clean_inline(str(opt)) or "Option")[:80] for opt in data.get("options", [])]
+
+        adapter = get_adapter()
+        thread = adapter.resolve_conversation(thread_id)
+        if not thread:
+            return web.json_response({"answer": "Thread not found"}, status=400)
+
+        future = asyncio.get_event_loop().create_future()
+        # conv_id is always None here - key just needs to be unique for cleanup.
+        approval_key = f"mcp_ask:{thread_id}:{uuid.uuid4().hex}"
+        session_manager.set_pending_approval(approval_key, future, "ask_question")
+
+        prompt = adapter.create_question_prompt(future, question, options, allow_write_in=True)
+        msg = await prompt.send(thread)
+        session_manager.pending_approval_messages[approval_key] = msg
+
+        try:
+            answer = await asyncio.wait_for(future, timeout=300)
+            return web.json_response({"answer": answer})
+        except asyncio.TimeoutError:
+            return web.json_response({"answer": "User did not respond in time."})
+        finally:
+            await prompt.finalize()
+            session_manager.pending_approval_messages.pop(approval_key, None)
+            session_manager.clear_pending_approval(approval_key)
+    except Exception as e:
+        return web.json_response({"answer": f"Error: {e}"}, status=500)
+
+
+async def handle_mcp_send_channel(request):
+    try:
+        data = await request.json()
+        channel_id = data.get("channel_id")
+        message = data.get("message", "")
+
+        adapter = get_adapter()
+        channel = adapter.resolve_conversation(channel_id)
+        if not channel:
+            return web.json_response({"error": "Channel not found"}, status=400)
+
+        chunks = [message[i : i + MAX_EMBED_LEN] for i in range(0, len(message), MAX_EMBED_LEN)]
+        for chunk in chunks:
+            await adapter.send_message(channel, chunk)
+
+        return web.json_response({"answer": "success"})
+    except Exception as e:
+        return web.json_response({"error": str(e)}, status=500)

package/src/api/voice_routes.py

@@ -0,0 +1,94 @@
+import asyncio
+
+from aiohttp import web
+
+from config import logger
+
+
+async def handle_stt_input(request):
+    try:
+        data = await request.json()
+        bot = request.app["bot"]
+        cog = bot.get_cog("VoiceCog")
+        if cog:
+            asyncio.create_task(cog.handle_stt_input(data))
+        return web.json_response({"success": True})
+    except Exception as e:
+        import traceback
+
+        logger.error(f"STT API error: {e}")
+        traceback.print_exc()
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_tts_finished(request):
+    """Called by voice-service/index.js the moment the bot's spoken reply
+    actually finishes playing (its audio queue drains). This is what
+    should start the "keep listening" countdown - not the moment the
+    user's speech was recognized, which is well before the bot has even
+    started replying."""
+    try:
+        data = await request.json()
+        guild_id = data.get("guild_id")
+        bot = request.app["bot"]
+        cog = bot.get_cog("VoiceCog")
+        if cog and guild_id:
+            cog.mark_tts_finished(str(guild_id))
+        return web.json_response({"success": True})
+    except Exception as e:
+        logger.error(f"tts_finished API error: {e}")
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_stt_partial(request):
+    """Called repeatedly by voice-service/index.js while the user is
+    still speaking, only during the post-wake active window (bounded,
+    default 60s - not always-on). Body is already-recognized {"text":
+    ...}, not audio; this just updates a live "listening..." message."""
+    try:
+        data = await request.json()
+        bot = request.app["bot"]
+        cog = bot.get_cog("VoiceCog")
+        if cog:
+            asyncio.create_task(cog.handle_stt_partial(data))
+        return web.json_response({"success": True})
+    except Exception as e:
+        logger.error(f"stt_partial API error: {e}")
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_stt_partial_cancel(request):
+    """Called when an utterance that had a live partial message showing
+    turned out too short to actually process, or got dropped because the
+    active window lapsed mid-utterance - cleans up that placeholder
+    instead of leaving "🎤 (listening...)" stuck forever."""
+    try:
+        data = await request.json()
+        guild_id = data.get("guild_id")
+        bot = request.app["bot"]
+        cog = bot.get_cog("VoiceCog")
+        if cog and guild_id:
+            asyncio.create_task(cog.cancel_stt_partial(str(guild_id)))
+        return web.json_response({"success": True})
+    except Exception as e:
+        logger.error(f"stt_partial_cancel API error: {e}")
+        return web.json_response({"error": str(e)}, status=500)
+
+
+async def handle_enroll_sample(request):
+    """Called by voice-service/index.js for each utterance a user makes
+    WHILE enrolling a wake word (see its `enrollingUsers` set) - raw
+    PCM/WAV bytes, same as /wake_check. Nothing gets matched against
+    this; it's just collected as a reference sample. See
+    VoiceCog.handle_enroll_sample for where samples actually get saved
+    (only once all of them are in)."""
+    try:
+        user_id = request.query.get("user_id")
+        audio_bytes = await request.read()
+        cog = request.app["bot"].get_cog("VoiceCog")
+        if cog and user_id and audio_bytes:
+            asyncio.create_task(cog.handle_enroll_sample(user_id, audio_bytes))
+        return web.json_response({"success": True})
+    except Exception as e:
+        logger.error(f"enroll_sample API error: {e}")
+        return web.json_response({"error": str(e)}, status=500)

package/src/approval/command_parser.py

@@ -0,0 +1,62 @@
+def parse_shell_commands(cmd: str) -> list[str]:
+    """
+    Parses a shell command string into individual sub-commands
+    separated by &&, ||, ;, or \n, respecting single and double quotes.
+    """
+    sub_cmds = []
+    current = []
+    in_single = False
+    in_double = False
+
+    i = 0
+    while i < len(cmd):
+        c = cmd[i]
+
+        if c == "'" and not in_double:
+            in_single = not in_single
+            current.append(c)
+        elif c == '"' and not in_single:
+            if i > 0 and cmd[i - 1] == "\\":
+                current.append(c)
+            else:
+                in_double = not in_double
+                current.append(c)
+        elif not in_single and not in_double:
+            if c == "\\":
+                current.append(c)
+                if i + 1 < len(cmd):
+                    current.append(cmd[i + 1])
+                    i += 1
+            elif c == "\n":
+                if current:
+                    sub_cmds.append("".join(current))
+                    current = []
+            elif c == ";":
+                if current:
+                    sub_cmds.append("".join(current))
+                    current = []
+            elif c == "&" and i + 1 < len(cmd) and cmd[i + 1] == "&":
+                if current:
+                    sub_cmds.append("".join(current))
+                    current = []
+                i += 1
+            elif c == "|":
+                if i + 1 < len(cmd) and cmd[i + 1] == "|":
+                    if current:
+                        sub_cmds.append("".join(current))
+                        current = []
+                    i += 1
+                else:
+                    if current:
+                        sub_cmds.append("".join(current))
+                        current = []
+            else:
+                current.append(c)
+        else:
+            current.append(c)
+        i += 1
+
+    if current:
+        sub_cmds.append("".join(current))
+
+    return [c.strip() for c in sub_cmds if c.strip()]

package/src/approval/tool_formatter.py

@@ -0,0 +1,68 @@
+import json
+import os
+
+TOOL_DISPLAY_NAMES = {
+    "view_file": "Read",
+    "write_to_file": "Write",
+    "replace_file_content": "Edit",
+    "multi_replace_file_content": "Edit",
+    "grep_search": "Grep",
+    "list_dir": "List",
+}
+
+PATH_ARG_KEYS = ["AbsolutePath", "TargetFile", "DirectoryPath"]
+
+DETAIL_FIELD_KEYS = {"Description", "Instruction", "TargetFile", "AbsolutePath", "DirectoryPath", "Query", "SearchPath"}
+
+
+def format_tool_display(tool_name: str, tool_input: dict) -> tuple[str, str, dict]:
+    """
+    Formats the tool name and input into user-friendly display text.
+    Returns: (tool_msg_text, desc_json, view_tool_input)
+    """
+    display_name = TOOL_DISPLAY_NAMES.get(tool_name, tool_name)
+
+    args_str = None
+    for key in PATH_ARG_KEYS:
+        if key in tool_input:
+            args_str = os.path.basename(tool_input[key])
+            break
+    if args_str is None:
+        args_str = ", ".join(f"{k}={v}" for k, v in tool_input.items() if len(str(v)) < 50)
+
+    tool_msg_text = f"● {display_name}({args_str})"
+    view_tool_input = tool_input
+
+    fields_text = ""
+    for k, v in tool_input.items():
+        if k in DETAIL_FIELD_KEYS:
+            fields_text += f"**{k}**: {v}\n"
+
+    code_text = ""
+    if "CodeContent" in tool_input:
+        code_text = f"\n**Code Content:**\n```python\n{tool_input['CodeContent'][:1000]}\n```"
+    elif "ReplacementChunks" in tool_input:
+        for i, chunk in enumerate(tool_input["ReplacementChunks"]):
+            code_text += f"\n**Replacement Chunk #{i + 1} (Lines {chunk.get('StartLine')}-{chunk.get('EndLine')}):**\n"
+            code_text += f"```python\n{chunk.get('ReplacementContent')[:500]}\n```"
+    elif "ReplacementContent" in tool_input:
+        code_text += f"\n**Replacement Content:**\n```python\n{tool_input['ReplacementContent'][:1000]}\n```"
+
+    if fields_text or code_text:
+        desc_json = f"\n{fields_text}{code_text}"
+    else:
+        desc_json = f"\n```json\n{json.dumps(tool_input, indent=2, ensure_ascii=False)[:1000]}\n```"
+
+    return tool_msg_text, desc_json, view_tool_input
+
+
+def format_bash_display(sub_cmd: str) -> tuple[str, str, dict]:
+    """
+    Formats a single bash sub-command for display.
+    """
+    is_long = "\n" in sub_cmd or len(sub_cmd) > 50
+    display_cmd = sub_cmd.split("\n")[0][:50] + "..." if is_long else sub_cmd
+    tool_msg_text = f"● Bash({display_cmd})"
+    view_tool_input = {"CommandLine": sub_cmd}
+    desc_json = f"\n```bash\n{sub_cmd}\n```" if is_long else ""
+    return tool_msg_text, desc_json, view_tool_input