ssh-licco 2.5.2__tar.gz → 2.6.0__tar.gz

{ssh_licco-2.5.2/ssh_licco.egg-info → ssh_licco-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 2.5.2
+Version: 2.6.0
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT

{ssh_licco-2.5.2 → ssh_licco-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ssh-licco"
-version = "2.5.2"
+version = "2.6.0"
 description = "SSH Model Context Protocol Server - Enable SSH functionality for AI models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -59,4 +59,5 @@ warn_unused_configs = true
 disallow_untyped_defs = false
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 testpaths = ["tests"]

{ssh_licco-2.5.2 → ssh_licco-2.6.0/ssh_licco.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-licco
-Version: 2.5.2
+Version: 2.6.0
 Summary: SSH Model Context Protocol Server - Enable SSH functionality for AI models
 Author-email: SSH LICCO Team <contact@ssh-licco.dev>
 License: MIT

{ssh_licco-2.5.2 → ssh_licco-2.6.0}/ssh_licco.egg-info/SOURCES.txt

@@ -46,4 +46,5 @@ tests/test_config_manager.py
 tests/test_key_manager.py
 tests/test_security.py
 tests/test_server.py
-tests/test_session_manager.py
+tests/test_session_manager.py
+tests/test_watchdog.py

{ssh_licco-2.5.2 → ssh_licco-2.6.0}/ssh_mcp/__init__.py

@@ -1,8 +1,8 @@
 # SSH-LICCO 版本信息
 # 所有代码中的版本信息都从这里读取
-# 版本号：2.5.2
+# 版本号：2.6.0
 
-__version__ = "2.5.2"
+__version__ = "2.6.0"
 __author__ = "Li Qi"
 __email__ = "1985694657@qq.com"
 __license__ = "MIT"

{ssh_licco-2.5.2 → ssh_licco-2.6.0}/ssh_mcp/handlers/execute.py

@@ -9,12 +9,12 @@ import uuid
 
 from mcp.types import TextContent
 
-from ..security import (
-    SecurityError,
-    command_validator,
-    format_backup_prompt,
-    generate_backup_command,
-    parse_deletion_command,
+from ..security import (
+    SecurityError,
+    command_validator,
+    format_backup_prompt,
+    generate_backup_command,
+    parse_deletion_command,
 )
 from .connect import handle_connect
 from .context import HandlerContext
@@ -152,9 +152,13 @@ Current security level: {os.getenv("SSH_SECURITY_LEVEL", "balanced")}""",
             ctx.logger.warning(f"User chose to delete without backup: {command}")
 
     if background:
+        ctx.logger.info(
+            f"[execute] background mode chosen for session={session_id} timeout={timeout}s"
+        )
         return await execute_background(ctx, session_id, command, args, timeout)
 
     # Normal execution
+    ctx.logger.info(f"[execute] normal mode session={session_id} timeout={timeout}s")
     session = await ctx.session_manager.get_session(session_id)
     if not session:
         return [TextContent(type="text", text=f"Session not found: {session_id}")]
@@ -181,9 +185,17 @@ Current security level: {os.getenv("SSH_SECURITY_LEVEL", "balanced")}""",
         stdin_data = sudo_pwd + "\n"
         get_pty = True
 
+    ctx.logger.info(
+        f"[execute] invoking session.execute_command for session={session_id} "
+        f"timeout={timeout}s get_pty={get_pty}"
+    )
     result = await session.execute_command(
         command, timeout=timeout, stdin_data=stdin_data, get_pty=get_pty
     )
+    ctx.logger.info(
+        f"[execute] session.execute_command returned for session={session_id} "
+        f"exit_code={result.get('exit_code')}"
+    )
 
     if ctx.audit:
         session_info = await ctx.session_manager.get_session(session_id)
@@ -214,6 +226,10 @@ async def execute_background(
     ctx: HandlerContext, session_id: str, command: str, args: dict, timeout: int
 ) -> list[TextContent]:
     """Execute a command as a background task with proper nohup + bash -c wrapping."""
+    ctx.logger.info(
+        f"[execute-background] starting task session={session_id} timeout={timeout}s "
+        f"command={command[:200]}"
+    )
     workdir = args.get("workdir", "/tmp")
     log_file = args.get("log_file", "/tmp/background_task.log")
     wait = args.get("wait", False)
@@ -298,10 +314,22 @@ async def execute_background(
     try:
         # Execute as a single command (background=False) — the wrapper
         # includes sleep + status check, so it returns in ~1 second.
+        ctx.logger.info(
+            f"[execute-background] launching nohup wrapper for session={session_id} "
+            f"task_id={task_id} timeout={timeout + 5}s"
+        )
         result = await ctx.session_manager.execute_command(
             session_id, check_cmd, timeout=timeout + 5, background=False
         )
+        ctx.logger.info(
+            f"[execute-background] wrapper returned for session={session_id} "
+            f"task_id={task_id} exit_code={result.get('exit_code')}"
+        )
     except Exception as e:
+        ctx.logger.error(
+            f"[execute-background] failed to start task for session={session_id} "
+            f"task_id={task_id}: {type(e).__name__}: {e}"
+        )
         return [TextContent(type="text", text=f"Error starting background task: {str(e)}")]
 
     start_stdout = (result.get("stdout") or "").strip()
@@ -328,6 +356,11 @@ async def execute_background(
         elif in_log:
             log_tail += line + "\n"
 
+    ctx.logger.info(
+        f"[execute-background] parsed status for session={session_id} "
+        f"task_id={task_id} pid={pid} status={status} exit_code_str={exit_code_str}"
+    )
+
     # ── 状态判定：区分 5 种情况 ──
     #
     # 1. ✅ SUCCESS         — STATUS=COMPLETED, EXIT=0   命令执行成功
@@ -540,6 +573,11 @@ async def wait_for_task_completion(
     elapsed = 0
     interval = 2
 
+    ctx.logger.info(
+        f"[wait-task] start waiting session={session_id} task_id={task_id} "
+        f"timeout={timeout}s log_file={log_file}"
+    )
+
     while elapsed < timeout:
         await asyncio.sleep(interval)
         elapsed += interval
@@ -552,6 +590,12 @@ async def wait_for_task_completion(
         result = await ctx.session_manager.execute_command(session_id, check_cmd, timeout=10)
         status = result.get("stdout", "").strip()
 
+        if elapsed % 10 == 0:
+            ctx.logger.debug(
+                f"[wait-task] heartbeat session={session_id} task_id={task_id} "
+                f"elapsed={elapsed}s status={status}"
+            )
+
         if status == "COMPLETED" or status == "NOT_FOUND":
             # 读取退出码
             exit_result = await ctx.session_manager.execute_command(
@@ -569,6 +613,10 @@ async def wait_for_task_completion(
             status_label = (
                 "Completed Successfully" if exit_code == 0 else f"Failed (exit code {exit_code})"
             )
+            ctx.logger.info(
+                f"[wait-task] completed session={session_id} task_id={task_id} "
+                f"elapsed={elapsed}s exit_code={exit_code}"
+            )
             return f"""Task {status_label}!
 
 Task ID: {task_id}
@@ -581,6 +629,10 @@ Command Output:
 {log_content}
 """
 
+    ctx.logger.warning(
+        f"[wait-task] timeout session={session_id} task_id={task_id} "
+        f"elapsed={elapsed}s timeout={timeout}s"
+    )
     return f"""Task Still Running (Timeout)
 
 Task ID: {task_id}

{ssh_licco-2.5.2 → ssh_licco-2.6.0}/ssh_mcp/server.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import asyncio
-import logging
 import os
 import shlex
 import threading
@@ -20,6 +19,7 @@ from .connection_config import ConnectionConfig
 from .handlers import HANDLERS, schemas
 from .handlers.context import HandlerContext
 from .key_manager import KeyManager
+from .logging_config import get_logger
 from .session_manager import SessionManager
 
 try:
@@ -27,7 +27,7 @@ try:
 except Exception:
     from . import __version__
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class Tunnel:

{ssh_licco-2.5.2 → ssh_licco-2.6.0}/ssh_mcp/session_manager.py

@@ -210,7 +210,33 @@ class SSHSession:
         async with self._connect_lock:
             self._state = SessionState.EXECUTING
             self._last_activity = datetime.now()
+            start_time = asyncio.get_event_loop().time()
+            heartbeat_task = None
+            truncated_cmd = command[:200].replace("\n", " ")
+
             try:
+                self._logger.info(
+                    f"[cmd-start] session={self.session_id} "
+                    f"host={self.config.host}:{self.config.port} "
+                    f"timeout={timeout}s background={background} get_pty={get_pty} "
+                    f"command={truncated_cmd}"
+                )
+
+                async def _heartbeat() -> None:
+                    try:
+                        elapsed = 0
+                        while True:
+                            await asyncio.sleep(10)
+                            elapsed += 10
+                            self._logger.debug(
+                                f"[cmd-heartbeat] session={self.session_id} "
+                                f"elapsed={elapsed}s still executing: {truncated_cmd}"
+                            )
+                    except asyncio.CancelledError:
+                        pass
+
+                heartbeat_task = asyncio.create_task(_heartbeat())
+
                 result = await self._executor.submit(
                     self._execute_command_sync,
                     command,
@@ -220,18 +246,42 @@ class SSHSession:
                     get_pty,
                     timeout=timeout + 5,
                 )
+
+                elapsed = asyncio.get_event_loop().time() - start_time
+                self._logger.info(
+                    f"[cmd-done] session={self.session_id} elapsed={elapsed:.1f}s "
+                    f"exit_code={result.get('exit_code')} command={truncated_cmd}"
+                )
                 return result
+            except asyncio.TimeoutError:
+                elapsed = asyncio.get_event_loop().time() - start_time
+                self._logger.error(
+                    f"[cmd-timeout] session={self.session_id} elapsed={elapsed:.1f}s "
+                    f"timeout={timeout}s command={truncated_cmd}"
+                )
+                raise
             except ConnectionError:
                 # 连接错误，标记为断开状态
                 self._state = SessionState.DISCONNECTED
                 raise
             except Exception as e:
+                elapsed = asyncio.get_event_loop().time() - start_time
+                self._logger.error(
+                    f"[cmd-error] session={self.session_id} elapsed={elapsed:.1f}s "
+                    f"error={type(e).__name__}: {e} command={truncated_cmd}"
+                )
                 # 其他异常也检查连接状态
                 if not self.is_connected:
                     self._state = SessionState.DISCONNECTED
                     raise ConnectionError(f"SSH connection lost during command execution: {str(e)}")
                 raise
             finally:
+                if heartbeat_task is not None:
+                    heartbeat_task.cancel()
+                    try:
+                        await heartbeat_task
+                    except asyncio.CancelledError:
+                        pass
                 if self.is_connected:
                     self._state = SessionState.CONNECTED
 

ssh_licco-2.6.0/tests/test_watchdog.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import asyncio
+import threading
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from ssh_mcp.watchdog import (
+    GlobalExceptionHandler,
+    Watchdog,
+    WatchdogEvent,
+    WatchdogStatus,
+    get_watchdog,
+    setup_global_exception_handler,
+)
+
+
+class TestWatchdogStatus:
+    def test_values(self):
+        assert WatchdogStatus.RUNNING.value == "running"
+        assert WatchdogStatus.STOPPED.value == "stopped"
+        assert WatchdogStatus.PAUSED.value == "paused"
+
+
+class TestWatchdogEvent:
+    def test_creation(self):
+        event = WatchdogEvent(
+            timestamp=datetime.now(),
+            event_type="TEST",
+            message="test event",
+        )
+        assert event.event_type == "TEST"
+        assert event.message == "test event"
+        assert event.details == {}
+
+    def test_with_details(self):
+        event = WatchdogEvent(
+            timestamp=datetime.now(),
+            event_type="TEST",
+            message="test",
+            details={"key": "value"},
+        )
+        assert event.details["key"] == "value"
+
+
+class TestWatchdog:
+    def setup_method(self):
+        Watchdog._instance = None
+
+    def _fresh_watchdog(self) -> Watchdog:
+        Watchdog._instance = None
+        return Watchdog()
+
+    def test_singleton(self):
+        w1 = Watchdog()
+        w2 = Watchdog()
+        assert w1 is w2
+
+    def test_initial_status_stopped(self):
+        w = self._fresh_watchdog()
+        assert w.status == WatchdogStatus.STOPPED
+
+    def test_register_task(self):
+        w = self._fresh_watchdog()
+        w.register_task("task-1", "Test Task", timeout=60)
+        tasks = w.get_tasks()
+        assert len(tasks) == 1
+        assert tasks[0].task_id == "task-1"
+
+    def test_unregister_task(self):
+        w = self._fresh_watchdog()
+        w.register_task("task-1", "Test Task")
+        w.unregister_task("task-1")
+        assert len(w.get_tasks()) == 0
+
+    def test_update_heartbeat(self):
+        w = self._fresh_watchdog()
+        w.register_task("task-1", "Test Task")
+        old_hb = w.get_tasks()[0].last_heartbeat
+        w.update_task_heartbeat("task-1")
+        new_hb = w.get_tasks()[0].last_heartbeat
+        assert new_hb >= old_hb
+
+    def test_update_heartbeat_nonexistent(self):
+        w = self._fresh_watchdog()
+        w.update_task_heartbeat("nonexistent")
+
+    def test_update_progress(self):
+        w = self._fresh_watchdog()
+        w.register_task("task-1", "Test Task")
+        w.update_task_progress("task-1", 50)
+        assert w.get_tasks()[0].progress == 50
+
+    def test_capture_exception(self):
+        w = self._fresh_watchdog()
+        w.capture_exception(ValueError("test error"), context="test")
+        events = w.get_events()
+        assert len(events) >= 1
+        assert events[0].event_type == "SYSTEM_ERROR"
+
+    def test_get_events_limit(self):
+        w = self._fresh_watchdog()
+        for i in range(5):
+            w.capture_exception(ValueError(f"error {i}"))
+        events = w.get_events(limit=3)
+        assert len(events) <= 3
+
+    def test_add_recovery_callback(self):
+        w = self._fresh_watchdog()
+        callback = MagicMock()
+        w.add_recovery_callback(callback)
+        assert callback in w._recovery_callbacks
+
+    def test_start_sets_running(self):
+        w = self._fresh_watchdog()
+        with patch.object(w, "_monitor_loop", MagicMock()):
+            with patch("asyncio.create_task", return_value=MagicMock()):
+                w.start()
+        assert w.status == WatchdogStatus.RUNNING
+        w.stop()
+
+    def test_stop_sets_stopped(self):
+        w = self._fresh_watchdog()
+        with patch.object(w, "_monitor_loop", MagicMock()):
+            with patch("asyncio.create_task", return_value=MagicMock()):
+                w.start()
+        w.stop()
+        assert w.status == WatchdogStatus.STOPPED
+
+    def test_start_already_running(self):
+        w = self._fresh_watchdog()
+        with patch.object(w, "_monitor_loop", MagicMock()):
+            with patch("asyncio.create_task", return_value=MagicMock()):
+                w.start()
+        with patch.object(w, "_monitor_loop", MagicMock()):
+            with patch("asyncio.create_task", return_value=MagicMock()):
+                w.start()
+        assert w.status == WatchdogStatus.RUNNING
+        w.stop()
+
+
+class TestGlobalExceptionHandler:
+    def test_enable(self):
+        handler = GlobalExceptionHandler()
+        mock_loop = MagicMock()
+        mock_loop.set_exception_handler = MagicMock()
+        mock_loop.get_exception_handler = MagicMock(return_value=None)
+        with patch("asyncio.get_event_loop", return_value=mock_loop):
+            handler.enable()
+        assert handler._enabled is True
+
+    def test_disable(self):
+        handler = GlobalExceptionHandler()
+        mock_loop = MagicMock()
+        mock_loop.set_exception_handler = MagicMock()
+        mock_loop.get_exception_handler = MagicMock(return_value=None)
+        mock_loop.set_exception_handler = MagicMock()
+        with patch("asyncio.get_event_loop", return_value=mock_loop):
+            handler.enable()
+            handler.disable()
+        assert handler._enabled is False
+
+    def test_disable_not_enabled(self):
+        handler = GlobalExceptionHandler()
+        handler.disable()
+        assert handler._enabled is False
+
+    def test_enable_already_enabled(self):
+        handler = GlobalExceptionHandler()
+        handler._enabled = True
+        handler.enable()
+        assert handler._enabled is True
+
+
+class TestGetWatchdog:
+    def test_returns_watchdog(self):
+        Watchdog._instance = None
+        w = get_watchdog()
+        assert isinstance(w, Watchdog)