PraisonAI 4.6.47__tar.gz → 4.6.48__tar.gz

{praisonai-4.6.47 → praisonai-4.6.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.47
+Version: 4.6.48
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.47
+Requires-Dist: praisonaiagents>=1.6.48
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.47 → praisonai-4.6.48}/PraisonAI.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PraisonAI
-Version: 4.6.47
+Version: 4.6.48
 Summary: PraisonAI is an AI Agents Framework with Self Reflection. PraisonAI application combines PraisonAI Agents, AutoGen, and CrewAI into a low-code solution for building and managing multi-agent LLM systems, focusing on simplicity, customisation, and efficient human-agent collaboration.
 Author: Mervin Praison
 License: MIT
@@ -11,7 +11,7 @@ Description-Content-Type: text/markdown
 Requires-Dist: rich>=13.7
 Requires-Dist: markdown>=3.5
 Requires-Dist: pyparsing>=3.0.0
-Requires-Dist: praisonaiagents>=1.6.47
+Requires-Dist: praisonaiagents>=1.6.48
 Requires-Dist: python-dotenv>=0.19.0
 Requires-Dist: litellm<2,>=1.83.14
 Requires-Dist: PyYAML>=6.0

{praisonai-4.6.47 → praisonai-4.6.48}/PraisonAI.egg-info/SOURCES.txt

@@ -82,6 +82,7 @@ praisonai/bots/_resilience.py
 praisonai/bots/_session.py
 praisonai/bots/_slack_approval.py
 praisonai/bots/_telegram_approval.py
+praisonai/bots/_typing_indicator.py
 praisonai/bots/_unknown_user.py
 praisonai/bots/_webhook_approval.py
 praisonai/bots/_whatsapp_web_adapter.py
@@ -508,6 +509,7 @@ praisonai/gateway/magic_link.py
 praisonai/gateway/origin_check.py
 praisonai/gateway/pairing.py
 praisonai/gateway/pairing_routes.py
+praisonai/gateway/port_utils.py
 praisonai/gateway/push_channels.py
 praisonai/gateway/push_delivery.py
 praisonai/gateway/push_polling.py
@@ -515,6 +517,7 @@ praisonai/gateway/push_presence.py
 praisonai/gateway/rate_limiter.py
 praisonai/gateway/redis_pubsub.py
 praisonai/gateway/server.py
+praisonai/gateway/unicode_utils.py
 praisonai/inbuilt_tools/__init__.py
 praisonai/inbuilt_tools/autogen_tools.py
 praisonai/inc/__init__.py
@@ -698,6 +701,7 @@ praisonai/sandbox/ssh.py
 praisonai/sandbox/subprocess.py
 praisonai/scheduler/__init__.py
 praisonai/scheduler/agent_scheduler.py
+praisonai/scheduler/async_agent_scheduler.py
 praisonai/scheduler/base.py
 praisonai/scheduler/daemon_manager.py
 praisonai/scheduler/deployment.py

{praisonai-4.6.47 → praisonai-4.6.48}/PraisonAI.egg-info/requires.txt

@@ -1,7 +1,7 @@
 rich>=13.7
 markdown>=3.5
 pyparsing>=3.0.0
-praisonaiagents>=1.6.47
+praisonaiagents>=1.6.48
 python-dotenv>=0.19.0
 litellm<2,>=1.83.14
 PyYAML>=6.0

{praisonai-4.6.47 → praisonai-4.6.48}/praisonai/agents_generator.py

@@ -555,7 +555,7 @@ class AgentsGenerator:
             for agent_name, agent_config in config['agents'].items():
                 role_config = dict(agent_config) if agent_config else {}
                 # Convert 'instructions' to 'backstory' if present
-                # Note: preserve 'instructions' key for framework adapters
+                # Note: preserve 'instructions' key for adapters that pass it to PraisonAgent
                 if 'instructions' in role_config and 'backstory' not in role_config:
                     role_config['backstory'] = role_config['instructions']
                 # Ensure required fields have defaults
@@ -736,4 +736,4 @@ class AgentsGenerator:
         if result.get("status") == "completed":
             return result.get("output", "Workflow completed successfully")
         else:
-            return f"Workflow failed: {result.get('error', 'Unknown error')}"
+            return f"Workflow failed: {result.get('error', 'Unknown error')}"

praisonai-4.6.48/praisonai/async_agent_scheduler.py

@@ -0,0 +1,23 @@
+"""Backward-compatible re-export. Prefer `praisonai.scheduler`.
+
+This module is deprecated. Use the canonical implementation in the
+scheduler package for full functionality including async support.
+"""
+
+import warnings
+
+warnings.warn(
+    "praisonai.async_agent_scheduler is deprecated; "
+    "use 'from praisonai.scheduler import AsyncAgentScheduler' instead.",
+    DeprecationWarning, 
+    stacklevel=2,
+)
+
+# Re-export from the canonical location
+from .scheduler.async_agent_scheduler import (  # noqa: F401
+    AsyncAgentScheduler, 
+    AsyncPraisonAgentExecutor, 
+    AsyncAgentExecutorInterface,
+    create_async_agent_scheduler,
+    logger,
+)

praisonai-4.6.48/praisonai/bots/_typing_indicator.py

@@ -0,0 +1,116 @@
+"""
+Telegram typing indicator renewal utility.
+
+Provides a background task to periodically renew typing indicators
+during long-running operations like agent.chat() calls.
+"""
+
+import asyncio
+import logging
+from typing import Any, Callable, Coroutine, Optional, TypeVar
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+class TypingIndicator:
+    """Manages typing indicator renewal during long operations."""
+    
+    def __init__(self, interval: float = 4.0):
+        """
+        Initialize typing indicator manager.
+        
+        Args:
+            interval: Seconds between typing renewals (default 4.0 for Telegram)
+        """
+        self.interval = interval
+        self._task: Optional[asyncio.Task] = None
+        self._cancelled = False
+    
+    async def start(self, typing_func: Callable[[], Any]) -> None:
+        """
+        Start typing indicator renewal task.
+        
+        Args:
+            typing_func: Async function that sends typing action
+        """
+        if self._task and not self._task.done():
+            # Already running
+            return
+        
+        self._cancelled = False
+        self._task = asyncio.create_task(self._typing_loop(typing_func))
+    
+    def cancel(self) -> None:
+        """Cancel the typing indicator renewal."""
+        self._cancelled = True
+        if self._task and not self._task.done():
+            self._task.cancel()
+    
+    async def _typing_loop(self, typing_func: Callable[[], Any]) -> None:
+        """
+        Background loop that periodically sends typing action.
+        
+        Args:
+            typing_func: Function to call for sending typing indicator
+        """
+        try:
+            while not self._cancelled:
+                try:
+                    # Send typing indicator
+                    if asyncio.iscoroutinefunction(typing_func):
+                        await typing_func()
+                    else:
+                        typing_func()
+                    
+                    # Wait for interval or until cancelled
+                    await asyncio.sleep(self.interval)
+                    
+                except asyncio.CancelledError:
+                    break
+                except Exception as e:
+                    logger.debug(f"Typing indicator send failed: {e}")
+                    # Continue trying even if one fails
+                    await asyncio.sleep(self.interval)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            logger.debug("Typing indicator loop ended")
+
+
+async def with_typing_renewal(
+    typing_func: Callable[[], Any],
+    operation_coro: Coroutine[Any, Any, T],
+    interval: float = 4.0,
+) -> T:
+    """
+    Execute an operation with typing indicator renewal.
+    
+    Args:
+        typing_func: Function to call for typing indication
+        operation_coro: Coroutine to execute while showing typing
+        interval: Seconds between typing renewals
+    
+    Returns:
+        Result of the operation
+    """
+    indicator = TypingIndicator(interval=interval)
+
+    try:
+        # Start typing renewal
+        await indicator.start(typing_func)
+
+        # Execute the operation
+        result = await operation_coro
+
+        return result
+
+    finally:
+        # Always cancel typing renewal and await cleanup
+        indicator.cancel()
+        if indicator._task is not None:
+            try:
+                await indicator._task
+            except (asyncio.CancelledError, Exception):
+                pass

{praisonai-4.6.47 → praisonai-4.6.48}/praisonai/bots/telegram.py

@@ -33,6 +33,7 @@ from ._debounce import InboundDebouncer
 from ._ack import AckReactor
 from ._unknown_user import UnknownUserHandler, BotContext
 from ._pairing_ui import PairingUIBuilder, PairingCallbackHandler
+from ..gateway.unicode_utils import safe_error_message, safe_log_message, extract_root_cause_from_error
 from ..gateway.pairing import PairingStore
 
 logger = logging.getLogger(__name__)
@@ -222,9 +223,6 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
                     logger.error(f"Message handler error: {e}")
             
             if self._agent and not message.is_command:
-                if self.config.typing_indicator:
-                    await update.message.chat.send_action("typing")
-                
                 # Ack reaction
                 ack_ctx = None
                 if self._ack.enabled:
@@ -255,11 +253,28 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
                 ) if update.message.from_user else ""
                 try:
                     message_text = await self._debouncer.debounce(user_id, message_text)
-                    response = await self._session.chat(
-                        self._agent, user_id, message_text,
-                        chat_id=str(update.message.chat_id) if update.message.chat_id else "",
-                        user_name=user_name,
-                    )
+                    
+                    # Show typing indicator with renewal during long operation
+                    if self.config.typing_indicator:
+                        from ._typing_indicator import with_typing_renewal
+                        
+                        async def _typing_action():
+                            await update.message.chat.send_action("typing")
+                        
+                        response = await with_typing_renewal(
+                            typing_func=_typing_action,
+                            operation_coro=self._session.chat(
+                                self._agent, user_id, message_text,
+                                chat_id=str(update.message.chat_id) if update.message.chat_id else "",
+                                user_name=user_name,
+                            )
+                        )
+                    else:
+                        response = await self._session.chat(
+                            self._agent, user_id, message_text,
+                            chat_id=str(update.message.chat_id) if update.message.chat_id else "",
+                            user_name=user_name,
+                        )
                     send_result = self.fire_message_sending(
                         str(update.message.chat_id), str(response),
                         reply_to=str(update.message.message_id),
@@ -278,8 +293,9 @@ class TelegramBot(ChatCommandMixin, MessageHookMixin):
                     if ack_ctx:
                         await self._ack.done(ack_ctx, react_fn=_tg_react, unreact_fn=_tg_unreact)
                 except Exception as e:
-                    logger.error(f"Agent error: {e}")
-                    await update.message.reply_text(f"Error: {str(e)}")
+                    logger.error(f"Agent error: {safe_log_message(e)}")
+                    user_error = extract_root_cause_from_error(str(e))
+                    await update.message.reply_text(f"Error: {safe_error_message(user_error)}")
         
         async def handle_voice(update: Update, context: ContextTypes.DEFAULT_TYPE):
             """Handle voice messages."""

{praisonai-4.6.47 → praisonai-4.6.48}/praisonai/cli/commands/gateway.py

@@ -17,7 +17,7 @@ app = typer.Typer(
 @app.command("start")
 def gateway_start(
     host: str = typer.Option("127.0.0.1", "--host", help="Host to bind to"),
-    port: int = typer.Option(8765, "--port", help="Port to listen on"),
+    port: Optional[int] = typer.Option(None, "--port", help="Port to listen on"),
     agents: Optional[str] = typer.Option(None, "--agents", help="Path to agent configuration file"),
     config: Optional[str] = typer.Option(None, "--config", help="Path to gateway.yaml for multi-bot mode"),
 ):
@@ -27,17 +27,54 @@ def gateway_start(
         praisonai gateway start
         praisonai gateway start --config gateway.yaml
         praisonai gateway start --agents agents.yaml --port 9000
+        GATEWAY_PORT=9000 praisonai gateway start
     """
+    import os
     from ..features.gateway import GatewayHandler
 
+    # Check for GATEWAY_PORT environment variable if port not specified
+    if port is None:
+        try:
+            port = int(os.environ.get("GATEWAY_PORT", "8765"))
+        except ValueError:
+            port = 8765
+
     handler = GatewayHandler()
     handler.start(host=host, port=port, agent_file=agents, config_file=config)
 
 
+@app.command("stop")
+def gateway_stop(
+    host: str = typer.Option("127.0.0.1", "--host", help="Gateway host"),
+    port: Optional[int] = typer.Option(None, "--port", help="Gateway port"),
+    force: bool = typer.Option(False, "--force", help="Force stop (kill process)"),
+):
+    """Stop a running gateway instance.
+
+    Examples:
+        praisonai gateway stop
+        praisonai gateway stop --port 9000
+        praisonai gateway stop --force
+    """
+    import os
+    from ..features.gateway import GatewayHandler
+    from ..output.console import get_output_controller
+    
+    # Check for GATEWAY_PORT environment variable if port not specified
+    if port is None:
+        try:
+            port = int(os.environ.get("GATEWAY_PORT", "8765"))
+        except ValueError:
+            port = 8765
+    
+    handler = GatewayHandler()
+    handler.stop(host=host, port=port, force=force)
+
+
 @app.command("status")
 def gateway_status(
     host: str = typer.Option("127.0.0.1", "--host", help="Gateway host"),
-    port: int = typer.Option(8765, "--port", help="Gateway port"),
+    port: Optional[int] = typer.Option(None, "--port", help="Gateway port"),
     daemon_only: bool = typer.Option(False, "--daemon-only", help="Show only daemon status"),
 ):
     """Check gateway status and daemon service status.
@@ -47,10 +84,18 @@ def gateway_status(
         praisonai gateway status --port 9000
         praisonai gateway status --daemon-only
     """
+    import os
     from ..features.gateway import GatewayHandler
     from praisonai.daemon import get_daemon_status
     from ..output.console import get_output_controller
     
+    # Check for GATEWAY_PORT environment variable if port not specified
+    if port is None:
+        try:
+            port = int(os.environ.get("GATEWAY_PORT", "8765"))
+        except ValueError:
+            port = 8765
+    
     output = get_output_controller()
     
     # Show daemon status
@@ -394,6 +439,7 @@ Manage the gateway server: praisonai gateway <command>
 
 [bold]Commands:[/bold]
   [green]start[/green]       Start the gateway server
+  [green]stop[/green]        Stop a running gateway instance
   [green]status[/green]      Check gateway and daemon status
   [green]channels[/green]    List channels from gateway.yaml
   [green]send[/green]        Send a test message to a channel

{praisonai-4.6.47 → praisonai-4.6.48}/praisonai/cli/features/doctor/checks/bot_checks.py

@@ -200,3 +200,141 @@ def check_bot_security(config: DoctorConfig) -> CheckResult:
         )
 
 
+@register_check(
+    id="multi_channel_tokens",
+    title="Multi-Channel Token Configuration", 
+    description="Check for duplicate tokens across channels and validate multi-channel setup",
+    category=CheckCategory.BOTS,
+    severity=CheckSeverity.MEDIUM,
+)
+def check_multi_channel_tokens(config: DoctorConfig) -> CheckResult:
+    """Check multi-channel token configuration for duplicates and naming conventions."""
+    start = time.time()
+    from praisonai.cli._paths import resolve_bot_config_path
+    config_path = getattr(config, 'config_file', None) or resolve_bot_config_path("bot.yaml")
+    
+    # Check if bot.yaml exists
+    if not os.path.exists(config_path):
+        return CheckResult(
+            id="multi_channel_tokens",
+            title="Multi-Channel Token Configuration",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.SKIP,
+            message=f"{config_path} not found - multi-channel check skipped",
+            duration_ms=(time.time() - start) * 1000,
+        )
+    
+    try:
+        from praisonai.bots._config_schema import load_and_validate_bot_yaml
+        config_data = load_and_validate_bot_yaml(config_path)
+        
+        warnings = []
+        errors = []
+        
+        # Extract token environment variables from channels
+        channel_tokens = {}  # env_var -> [channel_keys_using_it]
+        channel_platforms = {}  # platform -> [channel_keys]
+        
+        for channel_name, channel_config in config_data.channels.items():
+            platform = channel_config.platform
+            token_ref = channel_config.token
+            
+            # Track platforms
+            if platform not in channel_platforms:
+                channel_platforms[platform] = []
+            channel_platforms[platform].append(channel_name)
+            
+            # Extract environment variable from token reference like ${TELEGRAM_BOT_TOKEN}
+            if token_ref and token_ref.startswith("${") and token_ref.endswith("}"):
+                env_var = token_ref[2:-1]  # Remove ${ and }
+                if env_var not in channel_tokens:
+                    channel_tokens[env_var] = []
+                channel_tokens[env_var].append(channel_name)
+        
+        # Check for duplicate token usage by env var reference
+        for env_var, channels in channel_tokens.items():
+            if len(channels) > 1:
+                errors.append(f"Token {env_var} is used by multiple channels: {', '.join(channels)}")
+
+        # Also check duplicate token usage by resolved token value
+        token_value_to_channels = {}  # token_value -> [channel_keys]
+        for env_var, channels in channel_tokens.items():
+            token_value = os.environ.get(env_var)
+            if token_value:
+                token_value_to_channels.setdefault(token_value, []).extend(channels)
+
+        for _, channels in token_value_to_channels.items():
+            unique_channels = sorted(set(channels))
+            if len(unique_channels) > 1:
+                errors.append(
+                    f"Same bot token value is used by multiple channels: {', '.join(unique_channels)}"
+                )
+        
+        # Check for multi-platform channels with good naming conventions
+        for platform, channels in channel_platforms.items():
+            if len(channels) > 1:
+                # Multiple channels on same platform - check naming convention
+                for channel_name in channels:
+                    channel_config = config_data.channels[channel_name]
+                    token_ref = channel_config.token
+                    if token_ref and token_ref.startswith("${") and token_ref.endswith("}"):
+                        env_var = token_ref[2:-1]
+                        
+                        # Check if follows naming convention: PLATFORM_ROLE_BOT_TOKEN
+                        expected_pattern = f"{platform.upper()}_"
+                        if not env_var.startswith(expected_pattern) or not env_var.endswith("_BOT_TOKEN"):
+                            warnings.append(f"Channel '{channel_name}' token '{env_var}' doesn't follow naming convention '{platform.upper()}_<ROLE>_BOT_TOKEN'")
+        
+        # Check for missing tokens
+        missing_tokens = []
+        for env_var in channel_tokens.keys():
+            if not os.environ.get(env_var):
+                missing_tokens.append(env_var)
+        
+        # Determine status
+        if errors:
+            return CheckResult(
+                id="multi_channel_tokens",
+                title="Multi-Channel Token Configuration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.FAIL,
+                message=f"Token configuration errors: {len(errors)} duplicate(s) found",
+                details='\n'.join(errors + warnings),
+                remediation="Each channel must have a unique bot token. Create separate bots in @BotFather and use unique environment variables.",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        elif warnings or missing_tokens:
+            all_issues = warnings + [f"Missing token: {token}" for token in missing_tokens]
+            return CheckResult(
+                id="multi_channel_tokens",
+                title="Multi-Channel Token Configuration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.WARN,
+                message=f"Multi-channel setup with {len(all_issues)} recommendation(s)",
+                details='\n'.join(all_issues),
+                remediation="Consider following the naming convention PLATFORM_ROLE_BOT_TOKEN for clarity.",
+                duration_ms=(time.time() - start) * 1000,
+            )
+        else:
+            channel_count = sum(len(channels) for channels in channel_platforms.values())
+            return CheckResult(
+                id="multi_channel_tokens",
+                title="Multi-Channel Token Configuration",
+                category=CheckCategory.BOTS,
+                status=CheckStatus.PASS,
+                message=f"Multi-channel configuration looks good ({channel_count} channels)",
+                duration_ms=(time.time() - start) * 1000,
+            )
+            
+    except Exception as e:
+        return CheckResult(
+            id="multi_channel_tokens",
+            title="Multi-Channel Token Configuration",
+            category=CheckCategory.BOTS,
+            status=CheckStatus.ERROR,
+            message=f"Error checking multi-channel config: {str(e)[:100]}",
+            remediation="Fix bot.yaml syntax errors first",
+            duration_ms=(time.time() - start) * 1000,
+        )
+
+

{praisonai-4.6.47 → praisonai-4.6.48}/praisonai/cli/features/gateway.py

@@ -168,6 +168,82 @@ class GatewayHandler:
         except Exception as e:
             print(f"Error loading agents: {e}")
     
+    def stop(self, host: str = "127.0.0.1", port: int = 8765, force: bool = False) -> None:
+        """Stop a running gateway instance.
+        
+        Args:
+            host: Gateway host
+            port: Gateway port 
+            force: Force stop (kill process)
+        """
+        try:
+            from praisonai.gateway.port_utils import GatewayPIDLock
+        except ImportError as e:
+            print(f"Error: Gateway utilities not available. {e}")
+            return
+        
+        pid_lock = GatewayPIDLock(host=host, port=port)
+        lock_info = pid_lock.get_lock_info()
+        
+        if not lock_info:
+            print(f"No gateway PID lock found. Gateway may not be running on {host}:{port}")
+            return
+        
+        pid = lock_info['pid']
+        is_running = lock_info['is_running']
+        
+        if not is_running:
+            print(f"Gateway process (PID {pid}) is no longer running. Cleaning up stale lock.")
+            pid_lock.release_lock()
+            return
+        
+        if force:
+            self._force_kill_process(pid)
+        else:
+            self._graceful_stop_process(pid)
+        
+        # Clean up lock file
+        pid_lock.release_lock()
+        print(f"Gateway stopped (PID {pid})")
+    
+    def _graceful_stop_process(self, pid: int) -> None:
+        """Gracefully stop a process by sending SIGTERM."""
+        import signal
+        import time
+        import os
+        
+        try:
+            print(f"Sending stop signal to PID {pid}...")
+            os.kill(pid, signal.SIGTERM)
+            
+            # Wait up to 10 seconds for graceful shutdown
+            for _ in range(100):
+                try:
+                    os.kill(pid, 0)  # Check if process exists
+                    time.sleep(0.1)
+                except (OSError, ProcessLookupError):
+                    return  # Process has stopped
+            
+            print(f"Process {pid} did not stop gracefully, forcing...")
+            self._force_kill_process(pid)
+            
+        except (OSError, ProcessLookupError):
+            print(f"Process {pid} not found or already stopped")
+    
+    def _force_kill_process(self, pid: int) -> None:
+        """Force kill a process with SIGKILL (Windows: SIGTERM)."""
+        import signal
+        import os
+        import sys
+        
+        try:
+            print(f"Force killing PID {pid}...")
+            # Use SIGTERM on Windows since SIGKILL is not available
+            sig = signal.SIGTERM if sys.platform == "win32" else signal.SIGKILL
+            os.kill(pid, sig)
+        except (OSError, ProcessLookupError):
+            print(f"Process {pid} not found or already stopped")
+
     def status(self, host: str = "127.0.0.1", port: int = 8765) -> None:
         """Check gateway status.
         
@@ -178,6 +254,35 @@ class GatewayHandler:
         import urllib.request
         import json
         
+        # Check PID lock info first
+        try:
+            from praisonai.gateway.port_utils import GatewayPIDLock, is_port_in_use
+            pid_lock = GatewayPIDLock(host=host, port=port)
+            lock_info = pid_lock.get_lock_info()
+            
+            if lock_info:
+                pid = lock_info['pid']
+                is_running = lock_info['is_running']
+                lock_host = lock_info['host']
+                lock_port = lock_info['port']
+                
+                if is_running:
+                    print(f"Gateway PID lock: Process {pid} running ({lock_host}:{lock_port})")
+                else:
+                    print(f"Gateway PID lock: Stale lock (process {pid} not running)")
+            else:
+                print("Gateway PID lock: No lock file found")
+            
+            # Check if port is in use
+            if is_port_in_use(host, port):
+                print(f"Port {host}:{port}: In use")
+            else:
+                print(f"Port {host}:{port}: Available")
+                
+        except ImportError:
+            print("PID lock status: Utilities not available")
+        
+        # Try to connect to health endpoint
         url = f"http://{host}:{port}/health"
         
         try: