linkgravity 1.5.14 → 1.6.1

package/bin/cli.js

@@ -49,6 +49,9 @@ function runPm2(args, silent = true) {
             ...process.env,
             // pm2 gives Python a pipe not a TTY, so it block-buffers stdout and can sit on log lines indefinitely - force line buffering.
             PYTHONUNBUFFERED: '1',
+            // pm2 merges --update-env rather than replacing, so a LOG_LEVEL from an earlier run
+            // survives unless a value is passed every time.
+            LOG_LEVEL: process.env.LOG_LEVEL || 'INFO',
             // Version managers (fnm, nvm) put node on PATH from a shell hook the daemon never runs,
             // so the bot's own `node` lookup for voice-service would fail without this.
             PATH: `${path.dirname(process.execPath)}${path.delimiter}${process.env.PATH || ''}`,
@@ -106,7 +109,7 @@ function runSudoStepThen(sudoCommand, successMessage) {
     }
 }
 
-// Matches a leading timestamp from either loguru or aiohttp's access-log format; only strips the first bracket group so aiohttp's second "[INFO ]" bracket is left alone.
+// Matches a leading timestamp from either loguru or aiohttp's access-log format.
 const TIMESTAMP_PREFIX = /^\[?\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}\]?\s*/;
 // loguru's colorize=True puts an ANSI code before the timestamp digits, breaking the '^' anchor above.
 // eslint-disable-next-line no-control-regex
@@ -390,7 +393,15 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     }
 
     info('Starting LinkGravity daemon...');
-    runPm2(['start', LGY_SCRIPT_PATH, '--interpreter', pythonExe, '--name', LGY_PM2_NAME]);
+    runPm2([
+        'start',
+        LGY_SCRIPT_PATH,
+        '--interpreter',
+        pythonExe,
+        '--name',
+        LGY_PM2_NAME,
+        '--update-env',
+    ]);
     verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
 } else if (cmd === 'stop') {
     info('Stopping LinkGravity daemon...');
@@ -616,7 +627,15 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
 
     if (!procBeforeUpdate) {
         info("Daemon wasn't running - starting it fresh...");
-        runPm2(['start', LGY_SCRIPT_PATH, '--interpreter', pythonExe, '--name', LGY_PM2_NAME]);
+        runPm2([
+            'start',
+            LGY_SCRIPT_PATH,
+            '--interpreter',
+            pythonExe,
+            '--name',
+            LGY_PM2_NAME,
+            '--update-env',
+        ]);
         verifyStartup().then((ok) => process.exit(ok ? 0 : 1));
     } else if (wasOnline) {
         info('Restarting daemon to apply the update...');

package/bin/setup.js

@@ -112,13 +112,16 @@ async function collectSessionScopes(existingScopes) {
     return scopes;
 }
 
-async function collectUserIds(existingIds, platformLabel) {
+async function collectUserIds(existingIds, platformLabel, required = false) {
     const ids = [];
     const hasExisting = existingIds && existingIds.length > 0;
 
     p.note(
-        'ONLY these users can use the bot (leave completely empty to allow EVERYONE). ' +
-            'Not related to DMs - this only gates the channel/threads configured above.',
+        required
+            ? 'ONLY these users can use the bot. At least one is required - anyone who knows the ' +
+                  'bot username can message it, and there is no channel scope to fall back on.'
+            : 'ONLY these users can use the bot (leave completely empty to allow EVERYONE). ' +
+                  'Not related to DMs - this only gates the channel/threads configured above.',
         `Allowed ${platformLabel} Users`,
     );
 
@@ -143,7 +146,9 @@ async function collectUserIds(existingIds, platformLabel) {
     while (true) {
         const userId = await p.text({
             message: isFirst
-                ? `${platformLabel} User ID to allow (leave empty to allow EVERYONE):`
+                ? required
+                    ? `${platformLabel} User ID to allow (required - message @userinfobot to find yours):`
+                    : `${platformLabel} User ID to allow (leave empty to allow EVERYONE):`
                 : `Another ${platformLabel} user ID to allow (leave empty if done):`,
         });
         if (p.isCancel(userId)) {
@@ -151,7 +156,13 @@ async function collectUserIds(existingIds, platformLabel) {
             process.exit(0);
         }
 
-        if (!userId) break;
+        if (!userId) {
+            if (required && isFirst) {
+                p.note(`At least one allowed user is required for ${platformLabel}.`, 'Required');
+                continue;
+            }
+            break;
+        }
         isFirst = false;
 
         ids.push(userId.trim());
@@ -334,7 +345,7 @@ async function configureTelegram(existingSettings) {
     const existingTelegramUserIds = existingSettings.telegram_allowed_user_ids
         ? splitIds(existingSettings.telegram_allowed_user_ids)
         : [];
-    const telegramUserIds = await collectUserIds(existingTelegramUserIds, 'Telegram');
+    const telegramUserIds = await collectUserIds(existingTelegramUserIds, 'Telegram', true);
 
     const updates = {};
     if (telegramToken) updates.telegram_token = telegramToken;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.5.14",
+  "version": "1.6.1",
   "description": "Discord/Telegram bot bridge for the Antigravity (agy) CLI, with voice interaction support",
   "scripts": {
     "start": "node npm-scripts/run-dev.js",

package/src/api/ui_routes.py

@@ -7,6 +7,7 @@ import uuid
 from aiohttp import web
 
 from api.server import is_tool_allowed
+from approval.protected_paths import protected_reason
 from config import APPROVAL_TIMEOUT_SEC, MAX_EMBED_LEN, logger, session_manager
 from messengers.base import ScopeOption
 from messengers.registry import get_adapter_for_platform, get_adapter_for_thread
@@ -87,6 +88,12 @@ async def handle_approve_request(request):
         # 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}")
 
+        # Ahead of the auto-allow lookup: this must not be overridable by a persistent grant.
+        blocked = protected_reason(tool_input)
+        if blocked:
+            logger.warning(f"Blocked {tool_name} touching protected config: {tool_input!r}")
+            return web.json_response({"decision": "deny", "reason": blocked})
+
         target_thread = None
         target_thread_id = None
         for thread_id_str, sess in session_manager.get_all_sessions().items():

package/src/approval/diff_preview.py

@@ -0,0 +1,143 @@
+import difflib
+import os
+import re
+from pathlib import Path
+
+MAX_LINES = 120
+TAIL_LINES = 30
+MAX_CHARS = 5000
+CONTEXT_LINES = 3
+
+PATH_KEYS = ("TargetFile", "AbsolutePath")
+
+HUNK_HEADER = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)")
+
+MISSING = object()
+
+
+def _existing_text(tool_input: dict):
+    path = next((tool_input[k] for k in PATH_KEYS if tool_input.get(k)), None)
+    if not path:
+        return MISSING, None
+    if not os.path.isfile(path):
+        return "", path
+    try:
+        return Path(path).read_text(encoding="utf-8"), path
+    except (OSError, UnicodeDecodeError):
+        return MISSING, path
+
+
+def _find_replaced_text(tool_input: dict, haystack: str, replacement: str) -> str | None:
+    # agy doesn't say which key holds the replaced text, so candidates are checked against the
+    # file instead of trusted by name.
+    best = None
+    for key, value in tool_input.items():
+        if key in PATH_KEYS or not isinstance(value, str) or not value or value == replacement:
+            continue
+        if haystack.count(value) == 1 and (best is None or len(value) > len(best)):
+            best = value
+    return best
+
+
+def _entries(old: list[str], new: list[str], first_line: int, width: int) -> list[tuple[int, bool, str]]:
+    out, old_no, new_no = [], first_line, first_line
+    for line in difflib.unified_diff(old, new, lineterm="", n=CONTEXT_LINES):
+        if line.startswith(("---", "+++")):
+            continue
+
+        header = HUNK_HEADER.match(line)
+        if header:
+            # difflib counts from the start of what it was given, which is a slice of the file
+            # for chunk edits.
+            old_no = int(header.group(1)) + first_line - 1
+            new_no = int(header.group(2)) + first_line - 1
+            continue
+
+        sign, body = line[0], line[1:]
+        number = old_no if sign == "-" else new_no
+        # A removed line still sits at new_no, but it doesn't occupy one, so it anchors the gap
+        # marker without advancing past it.
+        out.append((new_no, sign != "-", f"{sign} {number:>{width}} | {body}"))
+        if sign in " -":
+            old_no += 1
+        if sign in " +":
+            new_no += 1
+    return out
+
+
+def _with_gaps(entries: list[tuple[int, bool, str]], total: int, width: int) -> list[str]:
+    def gap(count):
+        return f"{'':>{width + 5}}... ({count} unchanged {'line' if count == 1 else 'lines'})"
+
+    out, last = [], 0
+    for position, occupies, text in entries:
+        if position > last + 1:
+            out.append(gap(position - last - 1))
+        out.append(text)
+        last = position if occupies else max(last, position - 1)
+    if total > last:
+        out.append(gap(total - last))
+    return out
+
+
+def _clip(lines: list[str]) -> str:
+    if len(lines) > MAX_LINES:
+        head = MAX_LINES - TAIL_LINES - 1
+        lines = [*lines[:head], f"... ({len(lines) - head - TAIL_LINES} more lines)", *lines[-TAIL_LINES:]]
+    kept, size = [], 0
+    for line in lines:
+        if size + len(line) > MAX_CHARS:
+            kept.append(f"... ({len(lines) - len(kept)} more lines)")
+            break
+        kept.append(line)
+        size += len(line) + 1
+    return "\n".join(kept)
+
+
+def _render(name: str, entries, total: int, width: int) -> str | None:
+    if not entries:
+        return None
+    added = sum(1 for *_, text in entries if text.startswith("+"))
+    removed = sum(1 for *_, text in entries if text.startswith("-"))
+    return f"{name} · +{added} -{removed}\n{_clip(_with_gaps(entries, total, width))}"
+
+
+def build_diff(tool_input: dict) -> str | None:
+    before, path = _existing_text(tool_input)
+    if before is MISSING:
+        return None
+    name = os.path.basename(path)
+    on_disk = os.path.isfile(path)
+
+    chunks = tool_input.get("ReplacementChunks")
+    if chunks:
+        if not on_disk:
+            return None
+        existing = before.splitlines()
+        total = len(existing)
+        entries, width = [], len(str(total))
+        for chunk in chunks:
+            start, end = chunk.get("StartLine"), chunk.get("EndLine")
+            replacement = chunk.get("ReplacementContent")
+            if not isinstance(start, int) or not isinstance(end, int) or replacement is None:
+                return None
+            replaced_lines = replacement.splitlines()
+            total += len(replaced_lines) - (end - start + 1)
+            entries += _entries(existing[start - 1 : end], replaced_lines, start, width)
+        return _render(name, entries, total, width)
+
+    if "CodeContent" in tool_input:
+        content = tool_input["CodeContent"]
+    else:
+        replacement = tool_input.get("ReplacementContent")
+        if replacement is None or not on_disk:
+            return None
+        replaced = _find_replaced_text(tool_input, before, replacement)
+        if replaced is None:
+            return None
+        content = before.replace(replaced, replacement, 1)
+
+    old_lines, new_lines = before.splitlines(), content.splitlines()
+    width = len(str(max(len(old_lines), len(new_lines))))
+    label = f"{name} (new file)" if not on_disk else name
+    return _render(label, _entries(old_lines, new_lines, 1, width), len(new_lines), width)

package/src/approval/protected_paths.py

@@ -0,0 +1,42 @@
+import os
+import re
+from pathlib import Path
+
+from config import WORKSPACE_DIR
+
+AGENT_SUBDIR = "workspace"
+
+_DIR_MARKER = f"{WORKSPACE_DIR.parent.name}/{WORKSPACE_DIR.name}"
+
+# Shell commands arrive as one opaque string, so they are matched textually rather than resolved.
+CONFIG_DIR_RE = re.compile(re.escape(_DIR_MARKER) + rf"(?!/{re.escape(AGENT_SUBDIR)}\b)")
+
+NAME_RE = re.compile(r"(?<![\w.-])(?:lgy\.json|persistent_tools\.json|approve_token)(?![\w.])")
+
+REASON = "LinkGravity's own configuration is off limits - it holds the bot tokens."
+
+
+def _is_inside_config(value: str) -> bool:
+    try:
+        resolved = Path(os.path.expandvars(os.path.expanduser(value))).resolve()
+    except (OSError, ValueError):
+        return False
+    root = WORKSPACE_DIR.resolve()
+    return resolved.is_relative_to(root) and not resolved.is_relative_to(root / AGENT_SUBDIR)
+
+
+def protected_reason(tool_input) -> str | None:
+    if isinstance(tool_input, list):
+        return next((r for r in map(protected_reason, tool_input) if r), None)
+    if not isinstance(tool_input, dict):
+        return None
+
+    for value in tool_input.values():
+        if isinstance(value, (dict, list)):
+            nested = protected_reason(value)
+            if nested:
+                return nested
+        elif isinstance(value, str) and value:
+            if NAME_RE.search(value) or CONFIG_DIR_RE.search(value) or _is_inside_config(value):
+                return REASON
+    return None

package/src/approval/tool_formatter.py

@@ -1,6 +1,8 @@
 import json
 import os
 
+from approval.diff_preview import build_diff
+
 TOOL_DISPLAY_NAMES = {
     "view_file": "Read",
     "write_to_file": "Write",
@@ -39,14 +41,17 @@ def format_tool_display(tool_name: str, tool_input: dict) -> tuple[str, str, dic
             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```"
+    diff = build_diff(tool_input)
+    if diff:
+        code_text = f"\n**Changes:**\n```diff\n{diff}\n```"
+    elif "CodeContent" in tool_input:
+        code_text = f"\n**Code Content:**\n```\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```"
+            code_text += f"```\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```"
+        code_text += f"\n**Replacement Content:**\n```\n{tool_input['ReplacementContent'][:1000]}\n```"
 
     if fields_text or code_text:
         desc_json = f"\n{fields_text}{code_text}"

package/src/cogs/voice_cog.py

@@ -290,12 +290,13 @@ class VoiceCog(commands.Cog):
 
                     if own_word or not required:
                         if self.bot_settings.get("tts_enabled", True):
-                            welcome_audio = await self.tts("Voice connected.")
+                            welcome_audio = await self.tts("Voice connected.", cache=True)
                             if welcome_audio:
                                 await self._play_audio(str(guild_id), welcome_audio, suppress_active_window=True)
                     elif self.bot_settings.get("tts_enabled", True):
                         prompt_audio = await self.tts(
-                            "No wake word is set up yet. Please use the sound command to set one."
+                            "No wake word is set up yet. Please use the sound command to set one.",
+                            cache=True,
                         )
                         if prompt_audio:
                             await self._play_audio(str(guild_id), prompt_audio, suppress_active_window=True)
@@ -637,7 +638,7 @@ class VoiceCog(commands.Cog):
             if not text_to_ai:
                 self.logger.debug("STT: isolated wake word handled via direct TTS")
                 if self.bot_settings.get("tts_enabled", True):
-                    audio_reply = await self.tts("Yes, I am listening.")
+                    audio_reply = await self.tts("Yes, I am listening.", cache=True)
                     if audio_reply:
                         await self._play_audio(str(guild_id), audio_reply)
                 return

package/src/config.py

@@ -165,8 +165,10 @@ session_manager = SessionManager(DATA_DIR)
 
 def allowed(user_id, platform: str = "discord") -> bool:
     if platform == "telegram":
-        ids = TELEGRAM_ALLOWED_IDS
-    elif platform == "slack":
+        # Anyone who knows a Telegram bot's username can DM it, and there is no channel scope to
+        # fall back on, so an empty list must mean nobody rather than everyone.
+        return user_id in TELEGRAM_ALLOWED_IDS
+    if platform == "slack":
         ids = SLACK_ALLOWED_IDS
         user_id = str(user_id)  # Slack IDs are strings, not ints like Discord/Telegram
     else:

package/src/core/logger.py

@@ -6,6 +6,17 @@ from sys import stdout
 from loguru import logger
 
 
+class _InterceptHandler(logging.Handler):
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            level = logger.level(record.levelname).name
+        except ValueError:
+            level = record.levelno
+        # Without patching, {name} resolves to this file's frame instead of the library that logged.
+        patched = logger.patch(lambda r, name=record.name: r.update(name=name))
+        patched.opt(exception=record.exc_info).log(level, record.getMessage())
+
+
 def init_logger(workspace_dir: Path):
     logging.getLogger("discord").setLevel(logging.WARNING)
     # httpx is what python-telegram-bot uses under the hood for every getUpdates
@@ -22,6 +33,9 @@ def init_logger(workspace_dir: Path):
     # Defaults to INFO - set LOG_LEVEL=DEBUG then `lgy restart` for
     # verbose detail (e.g. agy_runner.py's raw agy stdout capture).
     level = os.environ.get("LOG_LEVEL", "INFO").upper()
+    # force=True drops handlers third-party libraries install for themselves, which otherwise
+    # print in their own format alongside loguru's.
+    logging.basicConfig(handlers=[_InterceptHandler()], level=getattr(logging, level, logging.INFO), force=True)
     logger.add(stdout, level=level, format=log_format, colorize=True)
     logger.add(
         LOG_DIR / "bot.log",

package/src/main_discord.py

@@ -281,8 +281,6 @@ async def run_discord(stop_event: asyncio.Event) -> None:
         logger.critical("Missing DISCORD_TOKEN - run `lgy setup`")
         return
 
-    discord.utils.setup_logging()
-
     async with bot:
         from cogs.voice_cog import VoiceCog
         from config import bot_settings, save_bot_settings

package/src/main_telegram.py

@@ -6,7 +6,15 @@ 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 config import (
+    TELEGRAM_ALLOWED_IDS,
+    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
@@ -252,6 +260,14 @@ async def run_telegram(stop_event: asyncio.Event) -> None:
         logger.critical("Missing TELEGRAM_TOKEN - set telegram_token in lgy.json first.")
         return
 
+    if not TELEGRAM_ALLOWED_IDS:
+        logger.critical(
+            "No telegram_allowed_user_ids configured - refusing to start. A Telegram bot is "
+            "reachable by anyone who knows its username, so run 'lgy setup' and register your "
+            "user ID (message @userinfobot to find it)."
+        )
+        return
+
     app = build_application()
     logger.info("✅ Telegram bot starting (polling mode)...")
     await app.initialize()

package/src/messengers/discord_adapter.py

@@ -7,7 +7,7 @@ from typing import Any
 
 import discord
 
-from config import logger
+from config import allowed, logger
 from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
@@ -21,6 +21,14 @@ from messengers.base import (
 
 
 class _ErrorLoggingView(discord.ui.View):
+    async def interaction_check(self, interaction: discord.Interaction) -> bool:
+        # discord.py lets anyone who can see the message press the button, so the allow-list has
+        # to be applied here as well as on the inbound message path.
+        if allowed(interaction.user.id):
+            return True
+        await interaction.response.send_message("⛔ You are not allowed to use this bot.", ephemeral=True)
+        return False
+
     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."

package/src/messengers/slack_adapter.py

@@ -12,7 +12,7 @@ from slack_bolt.app.async_app import AsyncApp
 from slack_sdk.errors import SlackApiError
 from slack_sdk.web.async_client import AsyncWebClient
 
-from config import logger, session_manager
+from config import allowed, logger, session_manager
 from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
@@ -222,13 +222,33 @@ class SlackAdapter(MessengerAdapter):
         actions = body.get("actions") or []
         if not actions:
             return
+        if not await self._reject_unauthorized(body):
+            return
         action_id = actions[0].get("action_id")
         handler = self._callbacks.pop(action_id, None)
         if handler is None:
             return  # expired/unknown action - nothing to do, Bolt already acked
         await handler(body, self.client)
 
+    async def _reject_unauthorized(self, body: dict) -> bool:
+        user_id = (body.get("user") or {}).get("id")
+        if allowed(user_id, "slack"):
+            return True
+        logger.warning(f"Rejected Slack interaction from unauthorized user {user_id}")
+        # Modal submissions carry no channel, so there is nowhere to post the notice.
+        channel = (body.get("channel") or {}).get("id")
+        if channel and user_id:
+            try:
+                await self.client.chat_postEphemeral(
+                    channel=channel, user=user_id, text="⛔ You are not allowed to use this bot."
+                )
+            except SlackApiError as e:
+                logger.warning(f"Failed to notify unauthorized Slack user {user_id}: {e}")
+        return False
+
     async def handle_view_submission(self, body: dict) -> None:
+        if not await self._reject_unauthorized(body):
+            return
         callback_id = (body.get("view") or {}).get("callback_id")
         handler = self._view_callbacks.pop(callback_id, None)
         if handler is None:

package/src/messengers/telegram_adapter.py

@@ -14,7 +14,7 @@ from telegram.constants import ChatAction
 from telegram.error import TelegramError
 from telegram.ext import ContextTypes
 
-from config import logger
+from config import allowed, logger
 from messengers.base import (
     IncomingAttachment,
     IncomingMessage,
@@ -162,6 +162,9 @@ class TelegramAdapter(MessengerAdapter):
         query = update.callback_query
         if query is None or query.data is None:
             return
+        if query.from_user is None or not allowed(query.from_user.id, "telegram"):
+            await query.answer("You are not allowed to use this bot.", show_alert=True)
+            return
         handler = self._callbacks.pop(query.data, None)
         if handler is None:
             await query.answer("This action has expired.", show_alert=True)

package/src/services/audio_service.py

@@ -7,7 +7,6 @@ from pathlib import Path
 from config import TTS_VOICE, bot_settings, logger
 
 # Verified against edge-tts's live voice list; a name that isn't in it fails at synthesis time.
-# Ordered - the first voice of a language is that language's default.
 TTS_VOICES = [
     "en-US-AriaNeural",
     "en-US-GuyNeural",
@@ -83,7 +82,6 @@ def default_voice_for(tag: str) -> str:
 
 
 def resolve_language() -> str:
-    # Mirrored by resolveLanguage() in voice-service/stt.js, which is what reaches Google.
     configured = bot_settings.get("language")
     if configured:
         return configured
@@ -101,7 +99,12 @@ def voice_for(text: str) -> str:
     return default_voice_for(script)
 
 
-async def tts(text: str, voice: str = None) -> bytes | None:
+# Synthesising a prompt costs a network round trip that lands directly in the wake-word
+# response time, so the fixed ones are kept rather than rebuilt.
+_fixed_phrase_cache: dict[tuple[str, str, str], bytes] = {}
+
+
+async def tts(text: str, voice: str = None, cache: bool = False) -> bytes | None:
     try:
         import edge_tts
 
@@ -115,12 +118,20 @@ async def tts(text: str, voice: str = None) -> bytes | None:
         pct = round((speed - 1.0) * 100)
         rate = f"{'+' if pct >= 0 else ''}{pct}%"
 
-        communicate = edge_tts.Communicate(clean, voice or voice_for(clean), rate=rate)
+        active_voice = voice or voice_for(clean)
+
+        key = (clean, active_voice, rate)
+        if cache and key in _fixed_phrase_cache:
+            return _fixed_phrase_cache[key]
+
+        communicate = edge_tts.Communicate(clean, active_voice, rate=rate)
         with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
             tmp = f.name
         await communicate.save(tmp)
         data = Path(tmp).read_bytes()
         os.unlink(tmp)
+        if cache:
+            _fixed_phrase_cache[key] = data
         return data
     except Exception as e:
         logger.exception(f"TTS error: {e}")

package/voice-service/stt.js

@@ -5,8 +5,8 @@ const { aglConfig } = require('./config');
 // Unofficial Google STT key - same default Python's SpeechRecognition (recognize_google) ships with.
 const GOOGLE_STT_KEY = 'AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw';
 
-// Mirrored by resolve_language() in src/services/audio_service.py. edge-tts voice names are
-// <lang>-<REGION>-<Name>, so a pre-1.6 config carries its language in tts_voice alone.
+// edge-tts voice names are <lang>-<REGION>-<Name>, so a config predating the language setting
+// carries its language in tts_voice alone.
 function resolveLanguage() {
     if (aglConfig.language) return aglConfig.language;
     const match = /^([a-z]{2}-[A-Z]{2})-/.exec(aglConfig.tts_voice || '');
@@ -41,6 +41,7 @@ function flacEncode(wavBuffer) {
 }
 
 async function googleSTT(wavBuffer, lang = LANGUAGE) {
+    const startedAt = Date.now();
     let flacBuffer;
     try {
         flacBuffer = await flacEncode(wavBuffer);
@@ -49,6 +50,8 @@ async function googleSTT(wavBuffer, lang = LANGUAGE) {
         return null;
     }
 
+    const encodedAt = Date.now();
+
     let res;
     try {
         res = await fetch(
@@ -65,6 +68,10 @@ async function googleSTT(wavBuffer, lang = LANGUAGE) {
     }
 
     const raw = await res.text();
+    console.debug(
+        `[STT] ${Math.round(wavBuffer.length / 192)}ms audio: flac ${encodedAt - startedAt}ms, ` +
+            `google ${Date.now() - encodedAt}ms`,
+    );
     console.debug('[STT] raw:', raw.trim().replace(/\n/g, ' | '));
     // Response is newline-delimited JSON, one object per line.
     for (const line of raw.trim().split('\n')) {