netra-zen 1.1.2__tar.gz → 1.2.0__tar.gz

{netra_zen-1.1.2/netra_zen.egg-info → netra_zen-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-zen
-Version: 1.1.2
+Version: 1.2.0
 Summary: Multi-instance Claude orchestrator for parallel task execution
 Home-page: https://github.com/netra-systems/zen
 Author:  Systems

{netra_zen-1.1.2 → netra_zen-1.2.0/netra_zen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netra-zen
-Version: 1.1.2
+Version: 1.2.0
 Summary: Multi-instance Claude orchestrator for parallel task execution
 Home-page: https://github.com/netra-systems/zen
 Author:  Systems

{netra_zen-1.1.2 → netra_zen-1.2.0}/netra_zen.egg-info/SOURCES.txt

@@ -53,6 +53,7 @@ tests/test_thread_handshake.py
 tests/test_thread_id_fix.py
 tests/test_thread_management.py
 tests/test_thread_resolution.py
+tests/test_timing_fix.py
 tests/test_workspace_detection.py
 tests/test_zen_commands.py
 tests/test_zen_integration.py

{netra_zen-1.1.2 → netra_zen-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "netra-zen"
-version = "1.1.2"
+version = "1.2.0"
 description = "Multi-instance Claude orchestrator for parallel task execution"
 readme = "README.md"
 authors = [

{netra_zen-1.1.2 → netra_zen-1.2.0}/scripts/agent_cli.py

@@ -2883,22 +2883,49 @@ class WebSocketClient:
                         self.connected = True
                         return True
                     else:
-                        # Handshake failed - backend might be using old reactive model
+                        # Handshake failed - server not ready to process messages
                         self.debug.debug_print(
-                            "WARNING: No proactive handshake received from server",
+                            "WARNING: Server handshake not completed - server not ready",
                             DebugLevel.BASIC,
                             style="yellow"
                         )
                         self.debug.debug_print(
-                            "Server may be using pre-2025-10-09 architecture (reactive handshake)",
+                            "Server still completing lifecycle phases (Initialize → Authenticate → Handshake → Prepare → Processing)",
                             DebugLevel.VERBOSE,
                             style="yellow"
                         )
 
-                        # Still mark as connected for backward compatibility
-                        # Old backends might work without the proactive handshake
-                        self.connected = True
-                        return True
+                        # Wait briefly for server to complete its phases and retry
+                        safe_console_print("⏳ Waiting for server to complete initialization...", style="yellow",
+                                         json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+                        await asyncio.sleep(3.0)  # Give server time to reach PROCESSING phase
+
+                        # Retry handshake once more
+                        self.debug.debug_print(
+                            "Retrying handshake after delay...",
+                            DebugLevel.VERBOSE,
+                            style="cyan"
+                        )
+                        handshake_success = await self._perform_handshake()
+                        if handshake_success:
+                            safe_console_print(f"✅ Connected with thread ID: {self.current_thread_id}", style="green",
+                                             json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+                            self.connected = True
+                            return True
+                        else:
+                            # Server still not ready - fail the connection
+                            self.debug.debug_print(
+                                "ERROR: Server not ready after retry",
+                                DebugLevel.BASIC,
+                                style="red"
+                            )
+                            safe_console_print("❌ Server not ready to process messages. Please try again.", style="red",
+                                             json_mode=self.config.json_mode, ci_mode=self.config.ci_mode)
+
+                            # Close WebSocket and fail gracefully
+                            if self.ws:
+                                await self.ws.close()
+                            return False
             except Exception as e:
                 self.debug.log_connection_attempt(method_name, self.config.ws_url, success=False, error=str(e))
                 self.debug.debug_print(
@@ -3027,7 +3054,8 @@ class WebSocketClient:
 
             # Server enters HANDSHAKING phase after authentication
             # and proactively sends handshake_response
-            handshake_timeout = 10.0  # Wait up to 10 seconds
+            # Use configured timeout or default to 10 seconds
+            handshake_timeout = self.handshake_timeout if hasattr(self, 'handshake_timeout') and self.handshake_timeout else 10.0
             start_time = asyncio.get_event_loop().time()
 
             try:
@@ -3274,14 +3302,64 @@ class WebSocketClient:
             )
 
         # CRITICAL: Send acknowledgment with the SAME thread_id
+        # Per WebSocket Client Lifecycle Guide, use "handshake_acknowledged"
         ack_message = {
-            "type": "session_acknowledged",
+            "type": "handshake_acknowledged",
             "thread_id": backend_thread_id,  # Echo back the same ID
             "timestamp": datetime.now(timezone.utc).isoformat()
         }
 
         await self.ws.send(json.dumps(ack_message))
 
+        # Per WebSocket Client Lifecycle Guide, wait for handshake_complete
+        # and then add delay for server to enter Phase 5 (Processing)
+        self.debug.debug_print(
+            "Waiting for handshake_complete confirmation...",
+            DebugLevel.VERBOSE,
+            style="cyan"
+        )
+
+        # Wait briefly for handshake_complete message
+        try:
+            complete_msg = await asyncio.wait_for(self.ws.recv(), timeout=2.0)
+            complete_data = json.loads(complete_msg)
+            if complete_data.get('type') == 'handshake_complete':
+                self.debug.debug_print(
+                    "✅ Received handshake_complete - Server at Phase 4 (Ready)",
+                    DebugLevel.VERBOSE,
+                    style="green"
+                )
+
+                # CRITICAL: Add delay for server to enter Phase 5 (Processing)
+                # Per documentation, 500ms is recommended
+                self.debug.debug_print(
+                    "Waiting 500ms for server to enter Phase 5 (Processing)...",
+                    DebugLevel.VERBOSE,
+                    style="cyan"
+                )
+                await asyncio.sleep(0.5)
+
+                self.debug.debug_print(
+                    "✅ Server should now be in Phase 5 (Processing) - ready for messages",
+                    DebugLevel.VERBOSE,
+                    style="green"
+                )
+        except asyncio.TimeoutError:
+            # If no handshake_complete, still add a delay to be safe
+            self.debug.debug_print(
+                "No handshake_complete received, adding safety delay",
+                DebugLevel.VERBOSE,
+                style="yellow"
+            )
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            self.debug.debug_print(
+                f"Error waiting for handshake_complete: {e}",
+                DebugLevel.VERBOSE,
+                style="yellow"
+            )
+            await asyncio.sleep(0.5)
+
         return True
 
     def _get_platform_cache_path(self) -> Path:
@@ -3622,6 +3700,27 @@ class WebSocketClient:
         if not self.ws:
             raise RuntimeError("WebSocket not connected")
 
+        # Check if connection handshake is fully complete
+        if not self.connected:
+            self.debug.debug_print(
+                "ERROR: Connection not ready - handshake not complete",
+                DebugLevel.BASIC,
+                style="red"
+            )
+            safe_console_print(
+                "\n❌ ERROR: Cannot send message - server not ready",
+                style="red",
+                json_mode=self.config.json_mode,
+                ci_mode=self.config.ci_mode
+            )
+            safe_console_print(
+                "The server is still completing its initialization phases.",
+                style="yellow",
+                json_mode=self.config.json_mode,
+                ci_mode=self.config.ci_mode
+            )
+            raise RuntimeError("Connection not ready - handshake incomplete. Server needs to reach Processing phase.")
+
         # Generate run_id
         self.run_id = f"cli_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{os.getpid()}"
 

{netra_zen-1.1.2 → netra_zen-1.2.0}/setup.py

@@ -8,7 +8,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="netra-zen",
-    version="1.1.2",
+    version="1.2.0",
     author=" Systems",
     author_email="pypi@netrasystems.ai",
     description="Multi-instance Claude orchestrator for parallel task execution",

netra_zen-1.2.0/tests/test_timing_fix.py

@@ -0,0 +1,243 @@
+"""
+Test for the timing fix that ensures CLI waits for server handshake
+before sending messages.
+
+This test verifies that:
+1. CLI waits for handshake_response before marking connection as ready
+2. CLI retries handshake with delay if server isn't ready
+3. CLI properly fails connection if server doesn't complete handshake
+4. No messages are sent before server reaches PROCESSING phase
+"""
+
+import asyncio
+import json
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch, call
+from datetime import datetime
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from scripts.agent_cli import WebSocketClient
+from shared import Environment, EnvironmentConfig
+
+
+class TestTimingFix(unittest.TestCase):
+    """Test suite for CLI timing fix"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.config = MagicMock()
+        self.config.ws_url = "ws://localhost:8000/ws"
+        self.config.environment = Environment.LOCAL
+        self.config.json_mode = False
+        self.config.ci_mode = False
+        self.token = "test_token"
+        self.debug = MagicMock()
+
+    @patch('scripts.agent_cli.websockets.connect')
+    async def test_successful_handshake_on_first_try(self, mock_connect):
+        """Test successful handshake on first attempt"""
+        # Mock WebSocket connection
+        mock_ws = AsyncMock()
+        mock_connect.return_value = mock_ws
+
+        # Mock handshake response
+        handshake_response = {
+            "type": "handshake_response",
+            "thread_id": "test-thread-123",
+            "user_id": "user-456",
+            "session_id": "session-789"
+        }
+        mock_ws.recv.return_value = json.dumps(handshake_response)
+
+        # Create client and connect
+        client = WebSocketClient(
+            self.config, self.token, self.debug,
+            send_logs=False, logs_count=10,
+            logs_project=None, logs_path=None,
+            logs_user=None, handshake_timeout=5
+        )
+
+        result = await client.connect()
+
+        # Assertions
+        self.assertTrue(result)
+        self.assertTrue(client.connected)
+        self.assertEqual(client.current_thread_id, "test-thread-123")
+        mock_ws.close.assert_not_called()
+
+    @patch('scripts.agent_cli.websockets.connect')
+    @patch('scripts.agent_cli.asyncio.sleep')
+    async def test_handshake_retry_after_delay(self, mock_sleep, mock_connect):
+        """Test handshake retry after delay when server not ready"""
+        # Mock WebSocket connection
+        mock_ws = AsyncMock()
+        mock_connect.return_value = mock_ws
+
+        # First attempt: timeout (server not ready)
+        # Second attempt: successful handshake
+        handshake_response = {
+            "type": "handshake_response",
+            "thread_id": "test-thread-123",
+            "user_id": "user-456",
+            "session_id": "session-789"
+        }
+
+        # Configure recv to timeout first, then succeed
+        mock_ws.recv.side_effect = [
+            asyncio.TimeoutError(),  # First handshake attempt times out
+            json.dumps(handshake_response)  # Second attempt succeeds
+        ]
+
+        # Create client and connect
+        client = WebSocketClient(
+            self.config, self.token, self.debug,
+            send_logs=False, logs_count=10,
+            logs_project=None, logs_path=None,
+            logs_user=None, handshake_timeout=1
+        )
+
+        result = await client.connect()
+
+        # Assertions
+        self.assertTrue(result)
+        self.assertTrue(client.connected)
+        self.assertEqual(client.current_thread_id, "test-thread-123")
+        mock_sleep.assert_called_once_with(3.0)  # Verify delay was applied
+        mock_ws.close.assert_not_called()
+
+    @patch('scripts.agent_cli.websockets.connect')
+    @patch('scripts.agent_cli.asyncio.sleep')
+    async def test_connection_fails_if_no_handshake(self, mock_sleep, mock_connect):
+        """Test connection fails properly when server never completes handshake"""
+        # Mock WebSocket connection
+        mock_ws = AsyncMock()
+        mock_connect.return_value = mock_ws
+
+        # Both handshake attempts timeout
+        mock_ws.recv.side_effect = [
+            asyncio.TimeoutError(),  # First attempt
+            asyncio.TimeoutError()   # Second attempt after retry
+        ]
+
+        # Create client and connect
+        client = WebSocketClient(
+            self.config, self.token, self.debug,
+            send_logs=False, logs_count=10,
+            logs_project=None, logs_path=None,
+            logs_user=None, handshake_timeout=1
+        )
+
+        result = await client.connect()
+
+        # Assertions
+        self.assertFalse(result)  # Connection should fail
+        self.assertFalse(client.connected)  # Should not be marked as connected
+        self.assertIsNone(client.current_thread_id)  # No thread ID assigned
+        mock_sleep.assert_called_once_with(3.0)  # Verify retry delay
+        mock_ws.close.assert_called_once()  # WebSocket should be closed
+
+    @patch('scripts.agent_cli.websockets.connect')
+    async def test_no_message_sent_without_handshake(self, mock_connect):
+        """Test that send_message fails if handshake not completed"""
+        # Mock WebSocket connection
+        mock_ws = AsyncMock()
+        mock_connect.return_value = mock_ws
+
+        # Handshake times out - no response
+        mock_ws.recv.side_effect = asyncio.TimeoutError()
+
+        # Create client and try to connect
+        client = WebSocketClient(
+            self.config, self.token, self.debug,
+            send_logs=False, logs_count=10,
+            logs_project=None, logs_path=None,
+            logs_user=None, handshake_timeout=1
+        )
+
+        # Connection should fail due to no handshake
+        result = await client.connect()
+        self.assertFalse(result)
+
+        # Attempting to send message should fail
+        with self.assertRaises(Exception) as context:
+            await client.send_message("test message")
+
+        # Verify no message was sent via WebSocket
+        mock_ws.send.assert_not_called()
+
+    @patch('scripts.agent_cli.websockets.connect')
+    async def test_connection_established_is_not_handshake(self, mock_connect):
+        """Test that connection_established event is not treated as handshake"""
+        # Mock WebSocket connection
+        mock_ws = AsyncMock()
+        mock_connect.return_value = mock_ws
+
+        # Send connection_established instead of handshake_response
+        connection_event = {
+            "type": "connection_established",
+            "message": "Connected to server"
+        }
+
+        # Then timeout (no actual handshake)
+        mock_ws.recv.side_effect = [
+            json.dumps(connection_event),
+            asyncio.TimeoutError()
+        ]
+
+        # Create client and connect
+        client = WebSocketClient(
+            self.config, self.token, self.debug,
+            send_logs=False, logs_count=10,
+            logs_project=None, logs_path=None,
+            logs_user=None, handshake_timeout=1
+        )
+
+        result = await client.connect()
+
+        # Connection should fail - connection_established is not a handshake
+        self.assertFalse(result)
+        self.assertFalse(client.connected)
+        self.assertIsNone(client.current_thread_id)
+
+
+def run_async_test(coro):
+    """Helper to run async tests"""
+    loop = asyncio.get_event_loop()
+    return loop.run_until_complete(coro)
+
+
+class AsyncTestRunner(unittest.TestCase):
+    """Wrapper to run async tests"""
+
+    def test_successful_handshake(self):
+        test = TestTimingFix()
+        test.setUp()
+        run_async_test(test.test_successful_handshake_on_first_try())
+
+    def test_retry_after_delay(self):
+        test = TestTimingFix()
+        test.setUp()
+        run_async_test(test.test_handshake_retry_after_delay())
+
+    def test_connection_fails(self):
+        test = TestTimingFix()
+        test.setUp()
+        run_async_test(test.test_connection_fails_if_no_handshake())
+
+    def test_no_early_messages(self):
+        test = TestTimingFix()
+        test.setUp()
+        run_async_test(test.test_no_message_sent_without_handshake())
+
+    def test_connection_established_ignored(self):
+        test = TestTimingFix()
+        test.setUp()
+        run_async_test(test.test_connection_established_is_not_handshake())
+
+
+if __name__ == '__main__':
+    unittest.main()