gitarsenal-cli 1.9.70 → 1.9.71

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-15T05:04:01.624Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-15T05:31:11.835Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/kill_claude/claude_code_agent.py

@@ -372,7 +372,7 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
                 
                 # Execute tool calls
                 if tool_calls:
-                    print(f"🤖 Claude requested {len(tool_calls)} tool call(s)")
+                    print(f"🤖 Agent requested {len(tool_calls)} tool call(s)")
                     tool_results = []
                     
                     for i, tool_call in enumerate(tool_calls, 1):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.70",
+  "version": "1.9.71",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/test_modalSandboxScript.py

@@ -541,28 +541,89 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 print("🎉 AGENT OUTPUT (LIVE)")
                 print("="*60)
                 
-                # Use Popen for real-time output streaming
+                # Use Popen for real-time output streaming with optimizations
+                import sys
+                import select
+                import fcntl
+                import os as os_module
+                
                 process = subprocess.Popen(
-                    ["python", "/python/kill_claude/claude_code_agent.py", claude_prompt],
+                    ["python", "-u", "/python/kill_claude/claude_code_agent.py", claude_prompt],  # -u for unbuffered output
                     cwd="/root",
                     stdout=subprocess.PIPE,
-                    stderr=subprocess.STDOUT,  # Merge stderr into stdout
+                    stderr=subprocess.PIPE,  # Keep separate for better handling
                     text=True,
-                    bufsize=1,  # Line buffered
-                    universal_newlines=True
+                    bufsize=0,  # Unbuffered for fastest output
+                    universal_newlines=True,
+                    env=dict(os.environ, PYTHONUNBUFFERED='1')  # Force unbuffered Python output
                 )
                 
-                # Stream output in real-time
+                # Make stdout and stderr non-blocking for faster reading
+                def make_non_blocking(fd):
+                    flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+                    fcntl.fcntl(fd, fcntl.F_SETFL, flags | os_module.O_NONBLOCK)
+                
+                make_non_blocking(process.stdout)
+                make_non_blocking(process.stderr)
+                
+                # Stream output in real-time with robust error handling
                 try:
-                    while True:
-                        output = process.stdout.readline()
-                        if output == '' and process.poll() is not None:
-                            break
-                        if output:
-                            print(output.rstrip())
+                    stdout_buffer = ""
+                    stderr_buffer = ""
+                    
+                    while process.poll() is None:
+                        try:
+                            # Use select for efficient I/O multiplexing with error handling
+                            ready, _, _ = select.select([process.stdout, process.stderr], [], [], 0.1)  # 100ms timeout
+                            
+                            for stream in ready:
+                                try:
+                                    if stream == process.stdout:
+                                        chunk = stream.read(1024)  # Read in chunks for efficiency
+                                        if chunk is not None and chunk:
+                                            stdout_buffer += chunk
+                                            # Process complete lines immediately
+                                            while '\n' in stdout_buffer:
+                                                line, stdout_buffer = stdout_buffer.split('\n', 1)
+                                                print(line, flush=True)  # Force immediate flush
+                                    elif stream == process.stderr:
+                                        chunk = stream.read(1024)
+                                        if chunk is not None and chunk:
+                                            stderr_buffer += chunk
+                                            # Process complete lines immediately  
+                                            while '\n' in stderr_buffer:
+                                                line, stderr_buffer = stderr_buffer.split('\n', 1)
+                                                print(f"STDERR: {line}", flush=True)
+                                except (BlockingIOError, OSError, ValueError):
+                                    # Handle various I/O errors gracefully
+                                    continue
+                        except (select.error, OSError):
+                            # If select fails, fall back to simple polling
+                            time.sleep(0.1)
+                            continue
+                    
+                    # Process any remaining output after process ends
+                    try:
+                        # Read any remaining data from streams
+                        remaining_stdout = process.stdout.read()
+                        remaining_stderr = process.stderr.read()
+                        
+                        if remaining_stdout:
+                            stdout_buffer += remaining_stdout
+                        if remaining_stderr:
+                            stderr_buffer += remaining_stderr
+                        
+                        # Output remaining buffered content
+                        if stdout_buffer.strip():
+                            print(stdout_buffer.strip(), flush=True)
+                        if stderr_buffer.strip():
+                            print(f"STDERR: {stderr_buffer.strip()}", flush=True)
+                    except (OSError, ValueError):
+                        # Handle cases where streams are already closed
+                        pass
                     
-                    # Wait for process to complete and get return code
-                    return_code = process.wait(timeout=600)  # 10 minute timeout
+                    # Get final return code
+                    return_code = process.returncode
                     
                     print("\n" + "="*60)
                     if return_code == 0:
@@ -576,9 +637,48 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                     process.kill()
                     process.wait()
                 except Exception as stream_error:
-                    print(f"\n⚠️ Error streaming output: {stream_error}")
-                    process.kill()
-                    process.wait()
+                    # print(f"\n⚠️ Error with advanced streaming: {stream_error}")
+                    # print("🔄 Falling back to simple streaming...")
+                    pass
+                    
+                    # Fallback to simple readline approach
+                    try:
+                        # Restart the process with simpler streaming
+                        if process.poll() is None:
+                            process.kill()
+                            process.wait()
+                        
+                        fallback_process = subprocess.Popen(
+                            ["python", "-u", "/python/kill_claude/claude_code_agent.py", claude_prompt],
+                            cwd="/root",
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT,
+                            text=True,
+                            bufsize=1,
+                            universal_newlines=True
+                        )
+                        
+                        # Simple line-by-line reading
+                        while True:
+                            line = fallback_process.stdout.readline()
+                            if line == '' and fallback_process.poll() is not None:
+                                break
+                            if line:
+                                print(line.rstrip(), flush=True)
+                        
+                        return_code = fallback_process.returncode
+                        
+                        print("\n" + "="*60)
+                        if return_code == 0:
+                            print("✅ Agent completed successfully!")
+                        else:
+                            print(f"⚠️ Agent exited with code: {return_code}")
+                        print("="*60)
+                        
+                    except Exception as fallback_error:
+                        print(f"\n❌ Fallback streaming also failed: {fallback_error}")
+                        print("⚠️ Agent may have completed, but output streaming failed")
+                        return_code = 1
                 
             except Exception as e:
                 print(f"❌ Error during repository setup: {e}")