linkgravity 1.7.5 → 1.8.1

package/README.md

@@ -60,7 +60,7 @@ Slack has more moving parts than the others - two separate tokens, and a few set
     - It's easy to grab the wrong token here - the page also shows a **User OAuth Token** (`xoxp-...`) further down, which is a different thing and won't work for this bot.
 5. **App Home** (left sidebar) > under **Show Tabs**, turn on **Messages Tab**, then check **Allow users to send Slash commands and messages from the messages tab** - this is what lets you DM the bot at all. (If this section looks greyed out, it's because step 3 hasn't been saved/installed yet - go back and do that first.)
 6. **Event Subscriptions** (left sidebar) > toggle **Enable Events** on > under **Subscribe to bot events**, add `message.channels`, `message.groups`, `message.im`, and `message.mpim` > **Save Changes**.
-7. **Slash Commands** (left sidebar) > **Create New Command**, four times, for `/new`, `/model`, `/credit`, and `/permissions` (any description/hint text is fine - only the command name matters).
+7. **Slash Commands** (left sidebar) > **Create New Command**, five times, for `/new`, `/model`, `/credit`, `/permissions`, and `/automode` (any description/hint text is fine - only the command name matters).
 8. Back on **OAuth & Permissions**, since scopes/events changed after the initial install, click **Reinstall to Workspace** to push those changes live. Any time you change scopes or events later, you'll need to repeat this step.
 9. In Slack itself, for any **channel** (not DM) you want the bot usable in, run `/invite @<your bot's name>` there first - the bot can't post in a channel it hasn't been added to.
 

package/bin/cli.js

@@ -59,6 +59,20 @@ function repairHookRegistration({ fresh = false } = {}) {
     }
 }
 
+function repairShellCompletion() {
+    // Runs on every update too (not just the rarely-rerun setup) so existing installs get cleaned up.
+    try {
+        const result = require('./completion').installCompletion();
+        if (result?.cleaned) {
+            console.log(
+                `${color.dim}Cleaned up a stale completion line in your shell rc file.${color.reset}`,
+            );
+        }
+    } catch {
+        // Best-effort - a broken shell rc file shouldn't fail the update.
+    }
+}
+
 function runPm2(args, silent = true) {
     const stdioOpt = silent ? 'pipe' : 'inherit';
     const result = spawnSync(process.execPath, [PM2_BIN, ...args], {
@@ -714,6 +728,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
 
     if (latestVersion === currentVersion) {
         repairHookRegistration();
+        repairShellCompletion();
         success(`Already up to date (v${currentVersion}).\n`);
         process.exit(0);
     }
@@ -737,6 +752,7 @@ if (cmd === 'version' || cmd === '-v' || cmd === '--version') {
     delete require.cache[require.resolve('../npm-scripts/ensure-env')];
     require('../npm-scripts/ensure-env').ensureEnvironment();
     repairHookRegistration({ fresh: true });
+    repairShellCompletion();
 
     if (!procBeforeUpdate) {
         const blocker = launchBlocker();

package/bin/completion.js

@@ -29,13 +29,21 @@ function installCompletion(shell = path.basename(process.env.SHELL || '')) {
 
     const dest = path.join(os.homedir(), ...target.dest);
     let rcUpdated = false;
+    let cleaned = 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') : '';
+            let existing = fs.existsSync(rc) ? fs.readFileSync(rc, 'utf8') : '';
+            // Strip any pre-marker `eval "$(lgy completion ...)"` line - lgy never had that subcommand.
+            const stale = /^\s*eval "\$\(lgy completion[^)]*\)"\s*$/gm;
+            if (stale.test(existing)) {
+                fs.writeFileSync(rc, existing.replace(stale, '').replace(/\n{3,}/g, '\n\n'));
+                existing = fs.readFileSync(rc, 'utf8');
+                cleaned = true;
+            }
             if (!existing.includes(MARKER)) {
                 fs.appendFileSync(rc, zshRcBlock(path.dirname(dest)));
                 rcUpdated = true;
@@ -44,7 +52,12 @@ function installCompletion(shell = path.basename(process.env.SHELL || '')) {
     } catch {
         return null;
     }
-    return { shell, file: dest, rc: rcUpdated ? path.join(os.homedir(), target.rc) : null };
+    return {
+        shell,
+        file: dest,
+        rc: rcUpdated ? path.join(os.homedir(), target.rc) : null,
+        cleaned,
+    };
 }
 
 module.exports = { installCompletion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linkgravity",
-  "version": "1.7.5",
+  "version": "1.8.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

@@ -78,6 +78,8 @@ def _clean_inline(text: str) -> str:
 async def handle_approve_request(request):
     # Tracks approval_keys registered this request so the exception handler can clean them up.
     registered_approval_keys = []
+    # Tracks prompts sent this request so a later exception can still finalize (disable) them.
+    sent_prompts = []
     try:
         data = await request.json()
         conv_id = data.get("conversation_id")
@@ -151,6 +153,7 @@ async def handle_approve_request(request):
             prompt = adapter.create_question_prompt(
                 future, question_text, options, multi_select=is_multi_select, allow_write_in=True
             )
+            sent_prompts.append(prompt)
             await send_ordered(target_thread_id, lambda: prompt.send(target_thread))
 
             try:
@@ -188,8 +191,8 @@ async def handle_approve_request(request):
                 if not sub_cmd:
                     continue
 
-                is_auto_allowed = False
-                if "\n" not in sub_cmd and "|" not in sub_cmd:
+                is_auto_allowed = session_manager.is_auto_mode()
+                if not is_auto_allowed and "\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", []):
@@ -234,6 +237,7 @@ async def handle_approve_request(request):
                 prompt = adapter.create_tool_approval_prompt(
                     future, "⚠️ Tool Execution Approval Required", prompt_desc, scope_options
                 )
+                sent_prompts.append(prompt)
 
                 sub_cmd_display, sub_cmd_desc, _ = format_bash_display(sub_cmd)
                 sub_cmd_formatted = f"```text\n{sub_cmd_display}\n```{sub_cmd_desc}"
@@ -270,7 +274,7 @@ async def handle_approve_request(request):
             return allow_response(tool_name, tool_input)
 
         else:
-            if is_tool_allowed(tool_name, tool_input):
+            if session_manager.is_auto_mode() or is_tool_allowed(tool_name, tool_input):
                 if target_thread and tool_msg_text:
                     await send_ordered(
                         target_thread_id, lambda: _send_chunked(adapter, target_thread, tool_msg_formatted)
@@ -287,6 +291,7 @@ async def handle_approve_request(request):
             prompt = adapter.create_tool_approval_prompt(
                 future, "⚠️ Tool Execution Approval Required", tool_msg_formatted, scope_options
             )
+            sent_prompts.append(prompt)
 
             async def _send_prompt():
                 await _send_chunked(adapter, target_thread, tool_msg_formatted)
@@ -316,4 +321,9 @@ async def handle_approve_request(request):
         logger.exception(f"Error in handle_approve_request: {e}")
         for key in registered_approval_keys:
             session_manager.clear_pending_approval(key)
+        for prompt in sent_prompts:
+            try:
+                await prompt.finalize()
+            except Exception:
+                pass
         return web.json_response({"decision": "allow"})

package/src/cogs/general_cog.py

@@ -275,6 +275,21 @@ class GeneralCog(commands.Cog):
         await handle.send(interaction.channel)
         await interaction.response.send_message("🔐 Permission list posted above.", ephemeral=True)
 
+    @app_commands.command(
+        name="automode", description="Auto-allow every approval globally, across all sessions (on/off)"
+    )
+    @app_commands.describe(state="on or off")
+    async def cmd_automode(self, interaction: discord.Interaction, state: str):
+        if not allowed(interaction.user.id):
+            return await interaction.response.send_message("❌ Denied", ephemeral=True)
+        if state.lower() not in ("on", "off"):
+            return await interaction.response.send_message("Use `on` or `off`.", ephemeral=True)
+
+        from services import permissions
+
+        msg = permissions.set_auto_mode(state.lower() == "on")
+        await interaction.response.send_message(msg)
+
     @app_commands.command(
         name="stop", description="Stop the currently generating response or task (Equivalent to ESC in CLI)"
     )

package/src/config.py

@@ -148,7 +148,7 @@ TMP_VOICE_DIR.mkdir(parents=True, exist_ok=True)
 
 MAX_EMBED_LEN = 1900
 STREAM_RATE_LIMIT_SEC = 0.5
-APPROVAL_TIMEOUT_SEC = 1800
+APPROVAL_TIMEOUT_SEC = 86400
 PERSISTENT_FILE = DATA_DIR / "persistent_tools.json"
 SESSION_FILE = DATA_DIR / "sessions.json"
 

package/src/core/agy_runner.py

@@ -229,7 +229,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 tool approval (up to 3600s).
+                # Slices let the timeout pause indefinitely while any approval is pending (hooks/hook.js waits up to 24h).
                 from config import session_manager as _sm
 
                 poll_slice = 5.0
@@ -348,7 +348,7 @@ async def agy_new_conversation(
     content: str, model: str = None, stream_queue: asyncio.Queue = None, thread_id: str = None, cwd: str = None
 ) -> tuple[str, str]:
     # --print consumes the next token as the prompt, so the flag must come first.
-    args = ["--dangerously-skip-permissions", "--print", content]
+    args = ["--dangerously-skip-permissions", "--print", content, "--print-timeout", "24h"]
     if model:
         args.extend(["--model", clean_model_name(model)])
     result_text = await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)
@@ -364,7 +364,7 @@ async def agy_send_message(
     thread_id: str = None,
     cwd: str = None,
 ) -> str:
-    args = ["--dangerously-skip-permissions", "--print", content, "--conversation", conv_id]
+    args = ["--dangerously-skip-permissions", "--print", content, "--conversation", conv_id, "--print-timeout", "24h"]
     if model:
         args.extend(["--model", clean_model_name(model)])
     return await run_agy(*args, stream_queue=stream_queue, thread_id=thread_id, cwd=cwd)

package/src/core/session_manager.py

@@ -20,6 +20,9 @@ class SessionManager:
         # conv_id -> current approval_key. Keyed by approval_key (not conv_id)
         # so a 2nd call can't overwrite the 1st's still-pending Future.
         self.active_approval_by_conv: dict[str, str] = {}
+        # Same, but keyed by the platform session id - needed because a brand-new session's
+        # conv_id isn't known to us until its first turn fully finishes (see set_pending_approval).
+        self.active_approval_by_thread: dict[str, str] = {}
 
         self.persistent_allowed: dict = self._load_persistent()
 
@@ -54,14 +57,22 @@ class SessionManager:
     def _load_persistent(self) -> dict:
         from config import logger
 
-        data = safe_load_json(self.persistent_file, {"tools": [], "commands": []}, logger=logger)
+        data = safe_load_json(self.persistent_file, {"tools": [], "commands": [], "auto_mode": False}, logger=logger)
         if isinstance(data, list):
-            return {"tools": data, "commands": []}
+            return {"tools": data, "commands": [], "auto_mode": False}
+        data.setdefault("auto_mode", False)
         return data
 
     def save_persistent(self):
         atomic_write_json(self.persistent_file, self.persistent_allowed)
 
+    def is_auto_mode(self) -> bool:
+        return bool(self.persistent_allowed.get("auto_mode"))
+
+    def set_auto_mode(self, enabled: bool):
+        self.persistent_allowed["auto_mode"] = enabled
+        self.save_persistent()
+
     def register_queue(self, thread_id: str, queue: asyncio.Queue):
         self.active_queues[str(thread_id)] = queue
 
@@ -111,12 +122,19 @@ class SessionManager:
         self.active_tts_tasks.pop(str(thread_id), None)
 
     def set_pending_approval(
-        self, approval_key: str, future: asyncio.Future, app_type: str = "tool", conv_id: str | None = None
+        self,
+        approval_key: str,
+        future: asyncio.Future,
+        app_type: str = "tool",
+        conv_id: str | None = None,
+        thread_id: str | None = None,
     ):
         self.pending_approvals[approval_key] = future
         self.pending_approval_types[approval_key] = app_type
         if conv_id:
             self.active_approval_by_conv[conv_id] = approval_key
+        if thread_id:
+            self.active_approval_by_thread[thread_id] = approval_key
 
     def get_pending_approval_by_conv(self, conv_id: str) -> asyncio.Future | None:
         """Looks up whichever approval is CURRENTLY active for a given
@@ -128,18 +146,35 @@ class SessionManager:
             return None
         return self.pending_approvals.get(approval_key)
 
+    def get_pending_approval_by_thread(self, thread_id: str) -> asyncio.Future | None:
+        """Same as get_pending_approval_by_conv, but keyed by the platform session id - use this
+        for a session that might still be "pending" (conv_id not assigned yet)."""
+        approval_key = self.active_approval_by_thread.get(thread_id)
+        if not approval_key:
+            return None
+        return self.pending_approvals.get(approval_key)
+
     def get_pending_approval_type_by_conv(self, conv_id: str) -> str:
         approval_key = self.active_approval_by_conv.get(conv_id)
         if not approval_key:
             return "tool"
         return self.pending_approval_types.get(approval_key, "tool")
 
+    def get_pending_approval_type_by_thread(self, thread_id: str) -> str:
+        approval_key = self.active_approval_by_thread.get(thread_id)
+        if not approval_key:
+            return "tool"
+        return self.pending_approval_types.get(approval_key, "tool")
+
     def clear_pending_approval(self, approval_key: str):
         self.pending_approvals.pop(approval_key, None)
         self.pending_approval_types.pop(approval_key, None)
         self.pending_approval_messages.pop(approval_key, None)
-        # Only remove the conv_id pointer if it still points at THIS key -
+        # Only remove the conv_id/thread_id pointer if it still points at THIS key -
         # a newer call may have already overwritten it.
         for conv, key in list(self.active_approval_by_conv.items()):
             if key == approval_key:
                 del self.active_approval_by_conv[conv]
+        for thread, key in list(self.active_approval_by_thread.items()):
+            if key == approval_key:
+                del self.active_approval_by_thread[thread]

package/src/handlers/thread_reply.py

@@ -22,8 +22,15 @@ from utils.utils import (
 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":
+    conv_id = session.get("conversation_id")
+    # Brand-new session: conv_id isn't assigned yet, so fall back to the platform-keyed lookup.
+    approval_type = (
+        session_manager.get_pending_approval_type_by_conv(conv_id)
+        if conv_id
+        else session_manager.get_pending_approval_type_by_thread(incoming.conversation_id)
+    )
+
+    if approval_type == "ask_question":
         pa.set_result(content)
         await adapter.send_message(thread, f'✅ *Answer Received (Write in): "{content}"*')
         return True
@@ -166,14 +173,19 @@ async def handle_thread_reply(bot, incoming: IncomingMessage):
 
     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():
+    # Brand-new session: conv_id isn't assigned until the first turn fully finishes, so fall back to platform id.
+    pa = (
+        session_manager.get_pending_approval_by_conv(conv_id)
+        if conv_id
+        else session_manager.get_pending_approval_by_thread(incoming.conversation_id)
+    )
+
+    if pa and not pa.done():
         handled = await handle_approval_reply(incoming, session, content, pa)
         if handled:
             return
 
-    has_pending_approval = bool(conv_id and pa and not pa.done())
+    has_pending_approval = bool(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
 

package/src/main_slack.py

@@ -83,9 +83,14 @@ async def cmd_model(ack, body, respond, context) -> None:
         return
     conversation_id, session = found
 
-    from cogs.general_cog import load_cached_models
+    import time
 
-    cached_models = load_cached_models()
+    import cogs.general_cog as general_cog
+
+    if time.time() - general_cog.last_models_fetch > 3600 and not general_cog.fetching_models:
+        general_cog.fetching_models = True
+        await general_cog.fetch_models_background()
+    cached_models = general_cog.cached_models
     current_model = session.get("model") or bot_settings.get("default_model")
 
     def _apply_model(final_model: str) -> str:
@@ -150,6 +155,24 @@ async def cmd_permissions(ack, body, respond, context) -> None:
     await handle.send(SlackConversationRef(channel=channel, thread_ts=None))
 
 
+async def cmd_automode(ack, body, respond, context) -> None:
+    await ack()
+    user_id = body["user_id"]
+
+    if not allowed(user_id, "slack"):
+        await respond("❌ Denied")
+        return
+
+    state = (body.get("text") or "").strip().lower()
+    if state not in ("on", "off"):
+        await respond("Usage: /automode on|off")
+        return
+
+    from services import permissions
+
+    await respond(permissions.set_auto_mode(state == "on"))
+
+
 async def cmd_credit(ack, body, respond, context) -> None:
     await ack()
     adapter: SlackAdapter = context["adapter"]
@@ -234,6 +257,7 @@ def build_app() -> tuple[AsyncApp, SlackAdapter]:
     app.command("/model")(cmd_model)
     app.command("/credit")(cmd_credit)
     app.command("/permissions")(cmd_permissions)
+    app.command("/automode")(cmd_automode)
     app.event("message")(on_message)
     app.action(re.compile(".*"))(on_action)
     app.view(re.compile(".*"))(on_view_submission)

package/src/main_telegram.py

@@ -95,9 +95,14 @@ async def cmd_model(update: Update, context) -> None:
         await update.message.reply_text("⚠️ No active session here. Start one with /new first.")
         return
 
-    from cogs.general_cog import load_cached_models
+    import time
 
-    cached_models = load_cached_models()
+    import cogs.general_cog as general_cog
+
+    if time.time() - general_cog.last_models_fetch > 3600 and not general_cog.fetching_models:
+        general_cog.fetching_models = True
+        await general_cog.fetch_models_background()
+    cached_models = general_cog.cached_models
     current_model = session.get("model") or bot_settings.get("default_model")
 
     def _apply_model(final_model: str) -> str:
@@ -157,6 +162,22 @@ async def cmd_permissions(update: Update, context) -> None:
     await handle.send(update.effective_chat.id)
 
 
+async def cmd_automode(update: Update, context) -> None:
+    user = update.effective_user
+    if not allowed(user.id, "telegram"):
+        await update.message.reply_text("❌ Denied")
+        return
+
+    state = (context.args[0] if context.args else "").lower()
+    if state not in ("on", "off"):
+        await update.message.reply_text("Usage: /automode on|off")
+        return
+
+    from services import permissions
+
+    await update.message.reply_text(permissions.set_auto_mode(state == "on"))
+
+
 async def cmd_credit(update: Update, context) -> None:
     user = update.effective_user
     adapter: TelegramAdapter = context.bot_data["adapter"]
@@ -230,6 +251,7 @@ async def on_ready(app: Application) -> None:
             BotCommand("model", "Change the AI model for this session"),
             BotCommand("credit", "Turn AI Credits on/off"),
             BotCommand("permissions", "View and remove allowed tools and commands"),
+            BotCommand("automode", "Auto-allow every approval globally (on/off)"),
         ]
     )
     logger.info(f"✅ Bot is fully online and ready! Logged in as @{app.bot.username}")
@@ -245,6 +267,7 @@ def build_application() -> Application:
     app.add_handler(CommandHandler("model", cmd_model))
     app.add_handler(CommandHandler("credit", cmd_credit))
     app.add_handler(CommandHandler("permissions", cmd_permissions))
+    app.add_handler(CommandHandler("automode", cmd_automode))
     app.add_handler(CallbackQueryHandler(adapter.handle_callback_query))
     app.add_handler(MessageHandler(filters.ALL & ~filters.COMMAND, on_message))
     app.add_error_handler(on_error)

package/src/messengers/slack_adapter.py

@@ -164,6 +164,7 @@ class _SlackPromptHandle(PromptHandle):
         self.channel: str | None = None
         self.ts: str | None = None
         self.outcome: ToolApprovalOutcome | None = None
+        self.resolved = False
 
     async def send(self, conversation_ref: SlackConversationRef) -> dict:
         try:
@@ -185,6 +186,12 @@ class _SlackPromptHandle(PromptHandle):
             self._cleanup()
         if self.ts is None:
             return
+        if not self.resolved:
+            # No button click happened - resolve() would have already rewritten text/blocks otherwise.
+            self.blocks = [b for b in self.blocks if b.get("type") != "actions"]
+            self.blocks.append(
+                {"type": "section", "text": {"type": "mrkdwn", "text": "⏰ *Expired - no response in time*"}}
+            )
         try:
             await self.client.chat_update(channel=self.channel, ts=self.ts, text=self.text, blocks=self.blocks)
         except SlackApiError as e:
@@ -390,6 +397,7 @@ class SlackAdapter(MessengerAdapter):
         elements = []
 
         async def resolve(decision: str, scope: ScopeOption | None, resp_body: dict, client: AsyncWebClient):
+            handle.resolved = True
             handle.outcome = ToolApprovalOutcome(decision=decision, scope=scope)
             if not decision_future.done():
                 decision_future.set_result(decision)
@@ -463,6 +471,7 @@ class SlackAdapter(MessengerAdapter):
         keys: list[str] = []
 
         async def resolve(chosen_text: str, note: str, body: dict, client: AsyncWebClient):
+            handle.resolved = True
             if not answer_future.done():
                 answer_future.set_result(chosen_text)
             new_text = f"✅ *{note}: {chosen_text}*"

package/src/services/permissions.py

@@ -5,6 +5,17 @@ from messengers.base import PermissionEntry
 PAGE_SIZE = 20
 
 
+def set_auto_mode(enabled: bool) -> str:
+    session_manager.set_auto_mode(enabled)
+    if enabled:
+        return (
+            "⚠️ **Auto-mode ON** — every tool/command approval will be auto-allowed globally, "
+            "across all sessions and platforms, until you run `/automode off`. Protected paths "
+            "are still blocked regardless."
+        )
+    return "🔒 Auto-mode OFF — approvals are back to normal."
+
+
 def list_entries() -> list[PermissionEntry]:
     allowed = session_manager.persistent_allowed
     return [