Change health check port from 8080 to 5720 and centralize all port constants

- Change HEALTH_CHECK_PORT from generic 8080 to non-standard 5720
- Add DEBUG_PORT, TEMPORAL_ADDRESS, REDIS_URL, AGENTEX_API_BASE_URL to centralized ports.py
- Update base_acp_server.py run() to reference ACP_SERVER_PORT constant
- Update debug_config.py, debug.py, agents.py CLI to use centralized DEBUG_PORT
- Update run_handlers.py to use TEMPORAL_ADDRESS and REDIS_URL from constants
- Update tests to reflect new health check port default

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: SWE Destroyer

src/agentex/lib/cli/commands/agents.py

@@ -12,6 +12,7 @@
 from agentex import Agentex
 from agentex.lib.cli.debug import DebugMode, DebugConfig
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.constants.ports import DEBUG_PORT as _DEFAULT_DEBUG_PORT
 from agentex.lib.cli.utils.cli_utils import handle_questionary_cancellation
 from agentex.lib.sdk.config.validation import (
     EnvironmentsValidationError,
@@ -269,7 +270,9 @@ def run(
     debug: bool = typer.Option(False, help="Enable debug mode for both worker and ACP (disables auto-reload)"),
     debug_worker: bool = typer.Option(False, help="Enable debug mode for temporal worker only"),
     debug_acp: bool = typer.Option(False, help="Enable debug mode for ACP server only"),
-    debug_port: int = typer.Option(5678, help="Port for remote debugging (worker uses this, ACP uses port+1)"),
+    debug_port: int = typer.Option(
+        _DEFAULT_DEBUG_PORT, help="Port for remote debugging (worker uses this, ACP uses port+1)"
+    ),
     wait_for_debugger: bool = typer.Option(False, help="Wait for debugger to attach before starting"),
 ) -> None:
     """

src/agentex/lib/cli/debug/debug_config.py

@@ -5,11 +5,13 @@
 import socket
 from enum import Enum
 
+from agentex.lib.constants.ports import DEBUG_PORT as _DEFAULT_DEBUG_PORT
 from agentex.lib.utils.model_utils import BaseModel
 
 
 class DebugMode(str, Enum):
     """Debug mode options"""
+
     WORKER = "worker"
     ACP = "acp"
     BOTH = "both"
@@ -18,91 +20,91 @@ class DebugMode(str, Enum):
 
 class DebugConfig(BaseModel):
     """Configuration for debug mode"""
-    
+
     enabled: bool = False
     mode: DebugMode = DebugMode.NONE
-    port: int = 5678
+    port: int = _DEFAULT_DEBUG_PORT
     wait_for_attach: bool = False
     auto_port: bool = True  # Automatically find available port if specified port is busy
-    
+
     @classmethod
     def create_worker_debug(
-        cls, 
-        port: int = 5678, 
+        cls,
+        port: int = _DEFAULT_DEBUG_PORT,
         wait_for_attach: bool = False,
-        auto_port: bool = True
+        auto_port: bool = True,
     ) -> "DebugConfig":
         """Create debug config for worker debugging"""
         return cls(
             enabled=True,
             mode=DebugMode.WORKER,
             port=port,
             wait_for_attach=wait_for_attach,
-            auto_port=auto_port
+            auto_port=auto_port,
         )
-    
+
     @classmethod
     def create_acp_debug(
-        cls, 
-        port: int = 5679, 
+        cls,
+        port: int = _DEFAULT_DEBUG_PORT + 1,
         wait_for_attach: bool = False,
-        auto_port: bool = True
+        auto_port: bool = True,
     ) -> "DebugConfig":
         """Create debug config for ACP debugging"""
         return cls(
             enabled=True,
             mode=DebugMode.ACP,
             port=port,
             wait_for_attach=wait_for_attach,
-            auto_port=auto_port
+            auto_port=auto_port,
         )
-    
+
     @classmethod
     def create_both_debug(
-        cls, 
-        worker_port: int = 5678,
-        _acp_port: int = 5679,
+        cls,
+        worker_port: int = _DEFAULT_DEBUG_PORT,
+        _acp_port: int = _DEFAULT_DEBUG_PORT + 1,
         wait_for_attach: bool = False,
-        auto_port: bool = True
+        auto_port: bool = True,
     ) -> "DebugConfig":
         """Create debug config for both worker and ACP debugging"""
         return cls(
             enabled=True,
             mode=DebugMode.BOTH,
             port=worker_port,  # Primary port for worker
             wait_for_attach=wait_for_attach,
-            auto_port=auto_port
+            auto_port=auto_port,
         )
-    
+
     def should_debug_worker(self) -> bool:
         """Check if worker should be debugged"""
         return self.enabled and self.mode in (DebugMode.WORKER, DebugMode.BOTH)
-    
+
     def should_debug_acp(self) -> bool:
         """Check if ACP should be debugged"""
         return self.enabled and self.mode in (DebugMode.ACP, DebugMode.BOTH)
-    
+
     def get_worker_port(self) -> int:
         """Get port for worker debugging"""
         return self.port
-    
+
     def get_acp_port(self) -> int:
         """Get port for ACP debugging"""
         if self.mode == DebugMode.BOTH:
             return self.port + 1  # Use port + 1 for ACP when debugging both
         return self.port
 
 
-def find_available_port(start_port: int = 5678, max_attempts: int = 10) -> int:
+def find_available_port(start_port: int = _DEFAULT_DEBUG_PORT, max_attempts: int = 10) -> int:
     """Find an available port starting from start_port"""
     for port in range(start_port, start_port + max_attempts):
         try:
             with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-                s.bind(('localhost', port))
+                s.bind(("localhost", port))
                 return port
         except OSError:
             continue
-    
+
     # If we can't find an available port, just return the start port
     # and let the debug server handle the error
     return start_port
@@ -112,4 +114,4 @@ def resolve_debug_port(config: DebugConfig, target_port: int) -> int:
     """Resolve the actual port to use for debugging"""
     if config.auto_port:
         return find_available_port(target_port)
-    return target_port 
+    return target_port

src/agentex/lib/cli/handlers/run_handlers.py

@@ -11,6 +11,10 @@
 # Import debug functionality
 from agentex.lib.cli.debug import DebugConfig, start_acp_server_debug, start_temporal_worker_debug
 from agentex.lib.utils.logging import make_logger
+from agentex.lib.constants.ports import (
+    REDIS_URL as _DEFAULT_REDIS_URL,
+    TEMPORAL_ADDRESS as _DEFAULT_TEMPORAL_ADDRESS,
+)
 from agentex.lib.cli.utils.path_utils import (
     get_file_paths,
     calculate_uvicorn_target_for_local,
@@ -94,16 +98,16 @@ async def start_temporal_worker_with_reload(
         worker_process = await start_temporal_worker(worker_path, env, manifest_dir)
         process_manager.add_process(worker_process)
         return asyncio.create_task(stream_process_output(worker_process, "WORKER"))
-    
+
     async def worker_runner() -> None:
         current_process: asyncio.subprocess.Process | None = None
         output_task: asyncio.Task[None] | None = None
-        
+
         console.print(f"[blue]Starting Temporal worker with auto-reload from {worker_path}...[/blue]")
-        
+
         async def start_worker() -> asyncio.subprocess.Process:
             nonlocal current_process, output_task
-            
+
             # PRE-RESTART CLEANUP - NEW!
             if current_process is not None:
                 # Extract agent name from worker path for cleanup
@@ -112,7 +116,7 @@ async def start_worker() -> asyncio.subprocess.Process:
                 console.print(f"FOUND AGENT_NAME FROM ENV VARS: {agent_name} {agent_name is None}")
                 if agent_name is None:
                     agent_name = worker_path.parent.parent.name
-                
+
                 # Perform cleanup if configured
                 if should_cleanup_on_restart():
                     console.print("[yellow]Cleaning up workflows before worker restart...[/yellow]")
@@ -121,7 +125,7 @@ async def start_worker() -> asyncio.subprocess.Process:
                     except Exception as e:
                         logger.warning(f"Cleanup failed: {e}")
                         console.print(f"[yellow]⚠ Cleanup failed: {str(e)}[/yellow]")
-            
+
             # Clean up previous process
             if current_process and current_process.returncode is None:
                 current_process.terminate()
@@ -130,41 +134,41 @@ async def start_worker() -> asyncio.subprocess.Process:
                 except asyncio.TimeoutError:
                     current_process.kill()
                     await current_process.wait()
-            
+
             # Cancel previous output task
             if output_task:
                 output_task.cancel()
                 try:
                     await output_task
                 except asyncio.CancelledError:
                     pass
-            
+
             current_process = await start_temporal_worker(worker_path, env, manifest_dir)
             process_manager.add_process(current_process)
             console.print("[green]Temporal worker started[/green]")
             return current_process
-        
+
         try:
             # Start initial worker
             current_process = await start_worker()
             if current_process:
                 output_task = asyncio.create_task(stream_process_output(current_process, "WORKER"))
-            
+
             # Watch for file changes
             async for changes in awatch(manifest_dir, recursive=True):
                 # Filter for Python files
-                py_changes = [(change, path) for change, path in changes if str(path).endswith('.py')]
-                
+                py_changes = [(change, path) for change, path in changes if str(path).endswith(".py")]
+
                 if py_changes:
                     changed_files = [str(Path(path).relative_to(worker_path.parent)) for _, path in py_changes]
                     console.print(f"[yellow]File changes detected: {changed_files}[/yellow]")
                     console.print("[yellow]Restarting Temporal worker...[/yellow]")
-                    
+
                     # Restart worker (with cleanup handled in start_worker)
                     await start_worker()
                     if current_process:
                         output_task = asyncio.create_task(stream_process_output(current_process, "WORKER"))
-                    
+
         except asyncio.CancelledError:
             # Clean shutdown
             if output_task:
@@ -173,7 +177,7 @@ async def start_worker() -> asyncio.subprocess.Process:
                     await output_task
                 except asyncio.CancelledError:
                     pass
-            
+
             if current_process and current_process.returncode is None:
                 current_process.terminate()
                 try:
@@ -182,7 +186,7 @@ async def start_worker() -> asyncio.subprocess.Process:
                     current_process.kill()
                     await current_process.wait()
             raise
-    
+
     return asyncio.create_task(worker_runner())
 
 
@@ -192,7 +196,7 @@ async def start_acp_server(
     """Start the ACP server process"""
     # Use file path relative to manifest directory if possible
     uvicorn_target = calculate_uvicorn_target_for_local(acp_path, manifest_dir)
-    
+
     cmd = [
         sys.executable,
         "-m",
@@ -296,11 +300,17 @@ async def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = Non
         manifest_dir = Path(manifest_path).parent
         if debug_config and debug_config.should_debug_acp():
             acp_process = await start_acp_server_debug(
-                file_paths["acp"], manifest.local_development.agent.port, agent_env, debug_config  # type: ignore[union-attr]
+                file_paths["acp"],
+                manifest.local_development.agent.port,
+                agent_env,
+                debug_config,  # type: ignore[union-attr]
             )
         else:
             acp_process = await start_acp_server(
-                file_paths["acp"], manifest.local_development.agent.port, agent_env, manifest_dir  # type: ignore[union-attr]
+                file_paths["acp"],
+                manifest.local_development.agent.port,
+                agent_env,
+                manifest_dir,  # type: ignore[union-attr]
             )
         process_manager.add_process(acp_process)
 
@@ -313,14 +323,14 @@ async def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = Non
         if is_temporal_agent(manifest) and file_paths["worker"]:
             if debug_config and debug_config.should_debug_worker():
                 # In debug mode, start worker without auto-reload to prevent conflicts
-                worker_process = await start_temporal_worker_debug(
-                    file_paths["worker"], agent_env, debug_config
-                )
+                worker_process = await start_temporal_worker_debug(file_paths["worker"], agent_env, debug_config)
                 process_manager.add_process(worker_process)
                 worker_task = asyncio.create_task(stream_process_output(worker_process, "WORKER"))
             else:
                 # Normal mode with auto-reload
-                worker_task = await start_temporal_worker_with_reload(file_paths["worker"], agent_env, process_manager, manifest_dir)
+                worker_task = await start_temporal_worker_with_reload(
+                    file_paths["worker"], agent_env, process_manager, manifest_dir
+                )
             tasks.append(worker_task)
 
         console.print(
@@ -333,7 +343,7 @@ async def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = Non
             await process_manager.wait_for_shutdown()
         except KeyboardInterrupt:
             console.print("\n[yellow]Received shutdown signal...[/yellow]")
-        
+
         # Cancel output streaming tasks
         for task in tasks:
             task.cancel()
@@ -351,9 +361,6 @@ async def run_agent(manifest_path: str, debug_config: "DebugConfig | None" = Non
         await process_manager.cleanup_processes()
 
 
-
-
-
 def create_agent_environment(manifest: AgentManifest) -> dict[str, str]:
     """Create environment variables for agent processes without modifying os.environ"""
     # Start with current environment
@@ -364,8 +371,8 @@ def create_agent_environment(manifest: AgentManifest) -> dict[str, str]:
     # TODO: Combine this logic with the deploy_handlers so that we can reuse the env vars
     env_vars = {
         "ENVIRONMENT": "development",
-        "TEMPORAL_ADDRESS": "localhost:7233",
-        "REDIS_URL": "redis://localhost:6379",
+        "TEMPORAL_ADDRESS": _DEFAULT_TEMPORAL_ADDRESS,
+        "REDIS_URL": _DEFAULT_REDIS_URL,
         "AGENT_NAME": manifest.agent.name,
         "ACP_TYPE": manifest.agent.acp_type,
         "ACP_URL": f"http://{manifest.local_development.agent.host_address}",  # type: ignore[union-attr]
@@ -377,6 +384,7 @@ def create_agent_environment(manifest: AgentManifest) -> dict[str, str]:
 
     # Add authorization principal if set - for local development, auth is optional
     from agentex.lib.cli.utils.auth_utils import _encode_principal_context
+
     encoded_principal = _encode_principal_context(manifest)
     if encoded_principal:
         env_vars[EnvVarKeys.AUTH_PRINCIPAL_B64] = encoded_principal

src/agentex/lib/constants/ports.py

@@ -12,4 +12,16 @@
 ACP_SERVER_PORT = 8718
 
 # Health check endpoint default port (configurable via HEALTH_CHECK_PORT env var)
-HEALTH_CHECK_PORT = 8080
+HEALTH_CHECK_PORT = 5720
+
+# Debug server default port (configurable via AGENTEX_DEBUG_PORT env var)
+DEBUG_PORT = 5678
+
+# Temporal server default address (configurable via TEMPORAL_ADDRESS env var)
+TEMPORAL_ADDRESS = "localhost:7233"
+
+# Default Redis URL (configurable via REDIS_URL env var)
+REDIS_URL = "redis://localhost:6379"
+
+# AgentEx API base URL (configurable via AGENTEX_BASE_URL env var)
+AGENTEX_API_BASE_URL = f"http://localhost:{AGENTEX_API_PORT}"

src/agentex/lib/sdk/fastacp/base/base_acp_server.py

@@ -382,6 +382,10 @@ async def async_generator(task_message_content_list: list[TaskMessageContent]):
     ACP Server Lifecycle Methods
     """
 
-    def run(self, host: str = "0.0.0.0", port: int = 8718, **kwargs):
+    def run(self, host: str = "0.0.0.0", port: int | None = None, **kwargs):
         """Start the Uvicorn server for async handlers."""
+        from agentex.lib.constants.ports import ACP_SERVER_PORT
+
+        if port is None:
+            port = ACP_SERVER_PORT
         uvicorn.run(self, host=host, port=port, **kwargs)

src/agentex/lib/types/agent_configs.py

@@ -55,7 +55,7 @@ class TemporalConfig(BaseModel):
     )
     health_check_port: int | None = Field(
         default=None,
-        description="Port for temporal worker health check endpoint. Defaults to 8080 if not specified.",
+        description="Port for temporal worker health check endpoint. Defaults to HEALTH_CHECK_PORT (5720) if not specified.",
     )
 
     @validator("workflows")