juno-code 1.0.47 → 1.0.49

package/dist/templates/services/gemini.py

@@ -9,6 +9,8 @@ import json
 import os
 import subprocess
 import sys
+import threading
+import time
 from datetime import datetime
 from typing import List, Optional, Tuple
 
@@ -351,9 +353,28 @@ Examples:
 
     def run_gemini(self, cmd: List[str], verbose: bool = False) -> int:
         """Execute the Gemini CLI and normalize streaming output for shell-backend consumption."""
+        capture_path = os.environ.get("JUNO_SUBAGENT_CAPTURE_PATH")
         if verbose:
-            print(f"Executing: {' '.join(cmd)}", file=sys.stderr)
-            print("-" * 80, file=sys.stderr)
+            # Truncate prompt in display to avoid confusing multi-line output
+            display_cmd = []
+            skip_next = False
+            for i, part in enumerate(cmd):
+                if skip_next:
+                    skip_next = False
+                    continue
+                if part == "-p" and i + 1 < len(cmd):
+                    prompt_val = cmd[i + 1]
+                    if len(prompt_val) > 80 or "\n" in prompt_val:
+                        first_line = prompt_val.split("\n")[0][:60]
+                        display_cmd.append(f'-p "{first_line}..." ({len(prompt_val)} chars)')
+                    else:
+                        display_cmd.append(f"-p {prompt_val}")
+                    skip_next = True
+                else:
+                    display_cmd.append(part)
+            if not capture_path:
+                print(f"Executing: {' '.join(display_cmd)}", file=sys.stderr)
+                print("-" * 80, file=sys.stderr)
 
         try:
             process = subprocess.Popen(
@@ -366,33 +387,92 @@ Examples:
                 cwd=self.project_path,
             )
 
-            pending = ""
-
-            if process.stdout:
-                for raw_line in process.stdout:
-                    combined = (pending + raw_line).replace("\x7f", "\n")
-                    pending = ""
-
-                    if not combined.strip():
-                        continue
+            # Watchdog thread: handles two scenarios where the stdout loop blocks:
+            # 1. Process exits but its stdout pipe stays open (inherited FDs)
+            # 2. Process itself never exits (hung event loop)
+            # The watchdog waits for an "output done" signal from the main thread
+            # (set when the stdout loop finishes). Once signaled, it gives the
+            # process a grace period to exit, then terminates it and closes stdout.
+            wait_timeout = int(os.environ.get("GEMINI_WAIT_TIMEOUT", "30"))
+            output_done = threading.Event()
+
+            def _stdout_watchdog():
+                """Terminate process and close stdout pipe if it hangs after output."""
+                # Wait until the main thread signals output is done,
+                # OR until the process exits on its own (poll every second).
+                while not output_done.is_set():
+                    if process.poll() is not None:
+                        break
+                    output_done.wait(timeout=1)
+
+                if output_done.is_set() and process.poll() is None:
+                    # Output is done but process hasn't exited — give it grace period.
+                    try:
+                        process.wait(timeout=wait_timeout)
+                    except subprocess.TimeoutExpired:
+                        print(
+                            f"Warning: Gemini process did not exit within {wait_timeout}s after output. Terminating.",
+                            file=sys.stderr
+                        )
+                        process.terminate()
+                        try:
+                            process.wait(timeout=5)
+                        except subprocess.TimeoutExpired:
+                            print("Warning: Gemini process did not respond to SIGTERM. Killing.", file=sys.stderr)
+                            process.kill()
+                            try:
+                                process.wait(timeout=5)
+                            except subprocess.TimeoutExpired:
+                                pass
 
-                    parts, pending = self._split_json_stream(combined)
+                # Process has exited (naturally or forcefully).
+                # Grace period for remaining pipe data to flush, then close stdout.
+                time.sleep(2)
+                try:
+                    if process.stdout and not process.stdout.closed:
+                        process.stdout.close()
+                except Exception:
+                    pass
 
-                    if parts:
-                        for part in parts:
-                            try:
-                                parsed = json.loads(part)
-                                formatted = self._format_event_pretty(parsed)
-                                print(formatted, flush=True)
-                            except Exception:
-                                print(part, flush=True)
-                        continue
+            watchdog = threading.Thread(target=_stdout_watchdog, daemon=True)
+            watchdog.start()
 
-                    # Fallback for non-JSON lines or partial content
-                    if pending:
-                        continue
+            pending = ""
 
-                    print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+            if process.stdout:
+                try:
+                    for raw_line in process.stdout:
+                        combined = (pending + raw_line).replace("\x7f", "\n")
+                        pending = ""
+
+                        if not combined.strip():
+                            continue
+
+                        parts, pending = self._split_json_stream(combined)
+
+                        if parts:
+                            for part in parts:
+                                try:
+                                    parsed = json.loads(part)
+                                    formatted = self._format_event_pretty(parsed)
+                                    print(formatted, flush=True)
+                                except Exception:
+                                    print(part, flush=True)
+                            continue
+
+                        # Fallback for non-JSON lines or partial content
+                        if pending:
+                            continue
+
+                        print(combined, end="" if combined.endswith("\n") else "\n", flush=True)
+                except ValueError:
+                    # Watchdog closed stdout because the process exited but the
+                    # pipe stayed open (inherited FDs from child processes).
+                    # This is expected — all output has been consumed.
+                    pass
+
+            # Signal watchdog that output is done (stdout loop has exited).
+            output_done.set()
 
             if pending.strip():
                 try:
@@ -401,7 +481,13 @@ Examples:
                 except Exception:
                     print(pending, flush=True)
 
-            process.wait()
+            # Ensure process has exited. The watchdog thread handles termination
+            # if the process hangs, so by this point it should already be dead.
+            # Use a short timeout as a safety net.
+            try:
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                pass  # Watchdog thread will handle cleanup
 
             if process.stderr and process.returncode != 0:
                 stderr_output = process.stderr.read()
@@ -414,7 +500,11 @@ Examples:
             print("\nInterrupted by user", file=sys.stderr)
             try:
                 process.terminate()
-                process.wait()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait(timeout=5)
             except Exception:
                 pass
             return 130