linkgravity 1.8.0 → 1.9.0

package/hooks/hook.js

@@ -9,7 +9,7 @@ const LGY_CONFIG_FILE = path.join(os.homedir(), '.gemini', 'linkgravity', 'lgy.j
 // Not "localhost" - the server binds 127.0.0.1 and node resolves localhost to ::1 first.
 const APPROVE_HOST = '127.0.0.1';
 const APPROVE_PORT = 18080;
-const TIMEOUT_MS = 3600 * 1000;
+const TIMEOUT_MS = 86400 * 1000;
 
 function emit(payload) {
     // Exits explicitly: the keep-alive socket and its hour-long timer stay open after the

package/npm-scripts/register-hook.js

@@ -20,7 +20,7 @@ const HOOK_REGISTRATIONS = [
         eventType: 'PreToolUse',
         name: 'discord-approval',
         fileName: 'hook.js',
-        defaultTimeout: 3600,
+        defaultTimeout: 86400,
         wrapInMatcher: true,
     },
     {
@@ -130,7 +130,7 @@ function removeRetiredHooks(config) {
     return removedAny;
 }
 
-function registerHook({ allowFirstTimeCreate = true, quiet = false } = {}) {
+function registerHook({ allowFirstTimeCreate = true, quiet = false, resetTimeouts = false } = {}) {
     const config = loadHooksConfig();
     config.hooks = config.hooks || {};
 
@@ -180,19 +180,34 @@ function registerHook({ allowFirstTimeCreate = true, quiet = false } = {}) {
             hookEntry.command = command;
             console.log(`🔗 Registered agy ${reg.eventType} hook '${reg.name}' -> ${scriptPath}`);
             wroteChange = true;
-        } else if (hookEntry.command !== command) {
-            backupBeforeFirstChange();
-            console.log(
-                `🔗 Fixing agy ${reg.eventType} hook '${reg.name}' in ${hooksJsonPath}` +
-                    (backedUp ? ` (previous version backed up to ${hooksJsonPath}.bak)` : '') +
-                    `:\n   was: ${hookEntry.command}\n   now: ${command}`,
-            );
-            hookEntry.command = command;
-            wroteChange = true;
-        } else if (!quiet) {
-            console.log(
-                `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${scriptPath}`,
-            );
+        } else {
+            let changedThisEntry = false;
+            if (hookEntry.command !== command) {
+                backupBeforeFirstChange();
+                console.log(
+                    `🔗 Fixing agy ${reg.eventType} hook '${reg.name}' in ${hooksJsonPath}` +
+                        (backedUp ? ` (previous version backed up to ${hooksJsonPath}.bak)` : '') +
+                        `:\n   was: ${hookEntry.command}\n   now: ${command}`,
+                );
+                hookEntry.command = command;
+                changedThisEntry = true;
+            }
+            // Only setup resets timeout - a passive `update` must not clobber a user-customized value.
+            if (resetTimeouts && hookEntry.timeout !== reg.defaultTimeout) {
+                backupBeforeFirstChange();
+                console.log(
+                    `🔗 Resetting agy ${reg.eventType} hook '${reg.name}' timeout: ${hookEntry.timeout}s -> ${reg.defaultTimeout}s`,
+                );
+                hookEntry.timeout = reg.defaultTimeout;
+                changedThisEntry = true;
+            }
+            if (changedThisEntry) {
+                wroteChange = true;
+            } else if (!quiet) {
+                console.log(
+                    `🔗 agy ${reg.eventType} hook '${reg.name}' already up to date -> ${scriptPath}`,
+                );
+            }
         }
     }
 

package/package.json

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

@@ -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:
@@ -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}"
@@ -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/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

@@ -208,13 +208,6 @@ async def run_agy(
                             stdout_chunks.append(clean)
                             if stream_queue is not None:
                                 await stream_queue.put((clean, False))
-                                if (
-                                    "(Calls tool:" in clean
-                                    or "Tool Output:" in clean
-                                    or "Tool Execute:" in clean
-                                    or clean.startswith("● ")
-                                ):
-                                    await stream_queue.put(("__SPLIT__", True))
 
                 async def read_stderr():
                     while True:
@@ -229,7 +222,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 while an approval is pending (hook.js waits up to 24h).
                 from config import session_manager as _sm
 
                 poll_slice = 5.0
@@ -348,7 +341,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 +357,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()
 
@@ -119,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
@@ -136,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/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}*"