linkgravity 1.6.0 → 1.7.0

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/completion.js

@@ -0,0 +1,50 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// bash and fish read these directories lazily, on the first completion attempt, so neither needs
+// an rc line. zsh's default fpath has no home-directory entry, so it gets three.
+const TARGETS = {
+    bash: { src: 'lgy.bash', dest: ['.local', 'share', 'bash-completion', 'completions', 'lgy'] },
+    zsh: { src: '_lgy', dest: ['.local', 'share', 'zsh', 'site-functions', '_lgy'], rc: '.zshrc' },
+    fish: { src: 'lgy.fish', dest: ['.config', 'fish', 'completions', 'lgy.fish'] },
+};
+
+const MARKER = '# linkgravity completion';
+
+function zshRcBlock(dir) {
+    return [
+        '',
+        MARKER,
+        `fpath+=("${dir}")`,
+        'autoload -Uz _lgy',
+        'whence compdef > /dev/null && compdef _lgy lgy linkgravity',
+        '',
+    ].join('\n');
+}
+
+function installCompletion(shell = path.basename(process.env.SHELL || '')) {
+    const target = TARGETS[shell];
+    if (!target) return null;
+
+    const dest = path.join(os.homedir(), ...target.dest);
+    let rcUpdated = false;
+    try {
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.copyFileSync(path.join(__dirname, 'completions', target.src), dest);
+
+        if (target.rc) {
+            const rc = path.join(os.homedir(), target.rc);
+            const existing = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+            if (!existing.includes(MARKER)) {
+                fs.appendFileSync(rc, zshRcBlock(path.dirname(dest)));
+                rcUpdated = true;
+            }
+        }
+    } catch {
+        return null;
+    }
+    return { shell, file: dest, rc: rcUpdated ? path.join(os.homedir(), target.rc) : null };
+}
+
+module.exports = { installCompletion };

package/bin/completions/_lgy

@@ -0,0 +1,33 @@
+#compdef lgy linkgravity
+
+local -a commands
+commands=(
+    'version:Print the installed version'
+    'start:Start bot in the background'
+    'stop:Stop the background bot'
+    'restart:Restart the background bot'
+    'logs:View bot logs'
+    'status:Show daemon status'
+    'enable:Start automatically on system boot'
+    'disable:Remove bot from system boot'
+    'setup:Run the configuration wizard'
+    'update:Install a newer version if one exists'
+    'help:Show the help message'
+)
+
+if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+fi
+
+case "$words[2]" in
+    logs)
+        [[ "$words[CURRENT-1]" == (-n|--tail) ]] && return
+        _values 'flag' \
+            '-f[Follow the log output]' \
+            '-n[Number of lines to show]' \
+            '--tail[Number of lines to show]' \
+            '-t[Show timestamps]' \
+            '--timestamp[Show timestamps]'
+        ;;
+esac

package/bin/completions/lgy.bash

@@ -0,0 +1,18 @@
+_lgy_completion() {
+  local cur prev
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  prev="${COMP_WORDS[COMP_CWORD - 1]}"
+
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "version start stop restart logs status enable disable setup update help" -- "$cur"))
+    return
+  fi
+
+  if [ "${COMP_WORDS[1]}" = "logs" ]; then
+    case "$prev" in
+    -n | --tail) return ;;
+    esac
+    COMPREPLY=($(compgen -W "-f -n --tail -t --timestamp" -- "$cur"))
+  fi
+}
+complete -F _lgy_completion lgy linkgravity

package/bin/completions/lgy.fish

@@ -0,0 +1,32 @@
+complete -c lgy -n __fish_use_subcommand -a version -d 'Print the installed version'
+complete -c lgy -n __fish_use_subcommand -a start -d 'Start bot in the background'
+complete -c lgy -n __fish_use_subcommand -a stop -d 'Stop the background bot'
+complete -c lgy -n __fish_use_subcommand -a restart -d 'Restart the background bot'
+complete -c lgy -n __fish_use_subcommand -a logs -d 'View bot logs'
+complete -c lgy -n __fish_use_subcommand -a status -d 'Show daemon status'
+complete -c lgy -n __fish_use_subcommand -a enable -d 'Start automatically on system boot'
+complete -c lgy -n __fish_use_subcommand -a disable -d 'Remove bot from system boot'
+complete -c lgy -n __fish_use_subcommand -a setup -d 'Run the configuration wizard'
+complete -c lgy -n __fish_use_subcommand -a update -d 'Install a newer version if one exists'
+complete -c lgy -n __fish_use_subcommand -a help -d 'Show the help message'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -s f -d 'Follow the log output'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -s n -d 'Number of lines to show'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -l tail -d 'Number of lines to show'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -s t -d 'Show timestamps'
+complete -c lgy -n '__fish_seen_subcommand_from logs' -l timestamp -d 'Show timestamps'
+complete -c linkgravity -n __fish_use_subcommand -a version -d 'Print the installed version'
+complete -c linkgravity -n __fish_use_subcommand -a start -d 'Start bot in the background'
+complete -c linkgravity -n __fish_use_subcommand -a stop -d 'Stop the background bot'
+complete -c linkgravity -n __fish_use_subcommand -a restart -d 'Restart the background bot'
+complete -c linkgravity -n __fish_use_subcommand -a logs -d 'View bot logs'
+complete -c linkgravity -n __fish_use_subcommand -a status -d 'Show daemon status'
+complete -c linkgravity -n __fish_use_subcommand -a enable -d 'Start automatically on system boot'
+complete -c linkgravity -n __fish_use_subcommand -a disable -d 'Remove bot from system boot'
+complete -c linkgravity -n __fish_use_subcommand -a setup -d 'Run the configuration wizard'
+complete -c linkgravity -n __fish_use_subcommand -a update -d 'Install a newer version if one exists'
+complete -c linkgravity -n __fish_use_subcommand -a help -d 'Show the help message'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -s f -d 'Follow the log output'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -s n -d 'Number of lines to show'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -l tail -d 'Number of lines to show'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -s t -d 'Show timestamps'
+complete -c linkgravity -n '__fish_seen_subcommand_from logs' -l timestamp -d 'Show timestamps'

package/bin/setup.js

@@ -494,6 +494,21 @@ async function runSetup() {
         await platformMenu(choice);
     }
 
+    const { installCompletion } = require('./completion');
+    const installed = installCompletion();
+    if (installed) {
+        p.note(
+            [
+                `Installed for ${installed.shell} at ${installed.file}.`,
+                installed.rc ? `Added a line to ${installed.rc}.` : null,
+                'Open a new shell to use it.',
+            ]
+                .filter(Boolean)
+                .join('\n'),
+            'Tab completion',
+        );
+    }
+
     p.outro('Setup complete.');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "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/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/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/messengers/slack_adapter.py

@@ -234,6 +234,8 @@ class SlackAdapter(MessengerAdapter):
         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:
@@ -245,6 +247,8 @@ class SlackAdapter(MessengerAdapter):
         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: