gitacc-switcher 1.4.0__tar.gz → 1.5.0__tar.gz

{gitacc_switcher-1.4.0/gitacc_switcher.egg-info → gitacc_switcher-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.4.0
+Version: 1.5.0
 Summary: Git Account Switcher - Manage multiple Git SSH accounts easily
 Home-page: https://github.com/ktechhub/gitacc_switcher
 Author: ktechhub

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/gitacc_switcher/__init__.py

@@ -1,4 +1,4 @@
 """Git Account Switcher - Manage multiple Git SSH accounts easily."""
 
-__version__ = "1.4.0"
+__version__ = "1.5.0"
 __author__ = "ktechhub"

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/gitacc_switcher/account_manager.py

@@ -384,6 +384,35 @@ class AccountManager:
 
         return True
 
+    def run_doctor(self) -> Dict[str, object]:
+        """Run read-only health checks on the SSH agent and managed key files.
+
+        Checks whether the SSH agent is running and reachable, and whether
+        each registered account's private key file exists, is readable, and
+        has safe permissions. Makes no changes.
+
+        Returns:
+            Dictionary with 'agent_running' (bool) and 'accounts' (dict
+            mapping account name to its key-file check result — see
+            SSHManager.check_key_file).
+        """
+        agent_running = self.ssh_manager.is_ssh_agent_running()
+
+        accounts = self.config_manager.read_accounts()
+        account_checks = {}
+        for account_name, account_info in accounts.items():
+            private_key = account_info.get("private_key")
+            if not private_key:
+                account_checks[account_name] = {
+                    "exists": False,
+                    "readable": False,
+                    "permissions_ok": False,
+                }
+                continue
+            account_checks[account_name] = self.ssh_manager.check_key_file(private_key)
+
+        return {"agent_running": agent_running, "accounts": account_checks}
+
     def get_status(self, repo_path: Optional[Path] = None) -> Dict[str, object]:
         """Report the currently active Git identity and SSH agent key, and
         which registered account (if any) they match.

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/gitacc_switcher/cli.py

@@ -48,6 +48,7 @@ class CLI:
         self._add_list_command(subparsers)
         self._add_logout_command(subparsers)
         self._add_status_command(subparsers)
+        self._add_doctor_command(subparsers)
         self._add_init_command(subparsers)
         self._add_verify_command(subparsers)
         self._add_update_command(subparsers)
@@ -79,6 +80,7 @@ Examples:
   gitacc list                   List all registered accounts
   gitacc logout                 Logout current account
   gitacc status                 Show the currently active account
+  gitacc doctor                 Run health checks on the SSH agent and keys
   gitacc init myaccount         Initialize repo with account validation
   gitacc verify                 Verify current account matches repo
   gitacc update myaccount       Update Git name for an account
@@ -175,6 +177,17 @@ Examples:
         )
         parser.set_defaults(func=self._handle_status)
 
+    def _add_doctor_command(self, subparsers: argparse._SubParsersAction) -> None:
+        """Add the 'doctor' command parser."""
+        parser = subparsers.add_parser(
+            "doctor",
+            help="Run health checks on the SSH agent and managed keys",
+            description="Check that the SSH agent is running and reachable, "
+            "and that each registered account's key file exists and has "
+            "safe permissions. Read-only.",
+        )
+        parser.set_defaults(func=self._handle_doctor)
+
     def _add_init_command(self, subparsers: argparse._SubParsersAction) -> None:
         """Add the 'init' command parser."""
         parser = subparsers.add_parser(
@@ -516,6 +529,40 @@ Examples:
 
         return 0
 
+    def _handle_doctor(self, args: argparse.Namespace) -> int:
+        """Handle the 'doctor' command."""
+        report = self.account_manager.run_doctor()
+        all_ok = True
+
+        if report.get("agent_running"):
+            echo_color("g", "✓ SSH agent is running and reachable")
+        else:
+            echo_color("r", "✗ SSH agent is not running or not reachable")
+            all_ok = False
+
+        accounts = report.get("accounts", {})
+        if not accounts:
+            echo_color("y", "No accounts registered yet.")
+
+        for account_name, check in accounts.items():
+            if not check.get("exists"):
+                echo_color("r", f'✗ Account "{account_name}": key file is missing')
+                all_ok = False
+            elif not check.get("readable"):
+                echo_color("r", f'✗ Account "{account_name}": key file is unreadable')
+                all_ok = False
+            elif not check.get("permissions_ok"):
+                echo_color(
+                    "r",
+                    f'✗ Account "{account_name}": key file permissions are too '
+                    "permissive (should be readable by owner only)",
+                )
+                all_ok = False
+            else:
+                echo_color("g", f'✓ Account "{account_name}": key file OK')
+
+        return 0 if all_ok else 1
+
     def _handle_init(self, args: argparse.Namespace) -> int:
         """Handle the 'init' command."""
         success = self.account_manager.init_repo(args.account_name)

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/gitacc_switcher/ssh_manager.py

@@ -6,7 +6,7 @@ import subprocess
 import tempfile
 import re
 from pathlib import Path
-from typing import List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 
 class SSHManager:
@@ -269,6 +269,32 @@ class SSHManager:
         parts = result.stdout.strip().split()
         return parts[1] if len(parts) >= 2 else None
 
+    def check_key_file(self, private_key_path: str) -> Dict[str, bool]:
+        """Check a managed private key file's existence, readability, and permissions.
+
+        Read-only; does not modify anything it checks.
+
+        Args:
+            private_key_path: Path to the private key file to check
+
+        Returns:
+            Dictionary with 'exists', 'readable', and 'permissions_ok' booleans.
+            'permissions_ok' is True when the file is not accessible to
+            group/other, matching the 0600 mode ssh-keygen gives private keys
+            on creation; it is only meaningful when 'exists' and 'readable'
+            are both True.
+        """
+        path = Path(private_key_path)
+        if not path.is_file():
+            return {"exists": False, "readable": False, "permissions_ok": False}
+
+        if not os.access(path, os.R_OK):
+            return {"exists": True, "readable": False, "permissions_ok": False}
+
+        mode = path.stat().st_mode
+        permissions_ok = (mode & 0o077) == 0
+        return {"exists": True, "readable": True, "permissions_ok": permissions_ok}
+
     def get_public_key_content(self, public_key_path: str) -> Optional[str]:
         """Read public key content.
 

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0/gitacc_switcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.4.0
+Version: 1.5.0
 Summary: Git Account Switcher - Manage multiple Git SSH accounts easily
 Home-page: https://github.com/ktechhub/gitacc_switcher
 Author: ktechhub

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacc-switcher"
-version = "1.4.0"
+version = "1.5.0"
 description = "Git Account Switcher - Manage multiple Git SSH accounts easily"
 readme = "README.md"
 requires-python = ">=3.7"

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/setup.py

@@ -9,7 +9,7 @@ long_description = readme_file.read_text() if readme_file.exists() else ""
 
 setup(
     name="gitacc-switcher",
-    version="1.4.0",
+    version="1.5.0",
     description="Git Account Switcher - Manage multiple Git SSH accounts easily",
     long_description=long_description,
     long_description_content_type="text/markdown",

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/tests/test_account_manager.py

@@ -531,3 +531,64 @@ class TestGetStatus:
 
         manager.ssh_manager.get_agent_fingerprints.assert_not_called()
         assert status["matched_key_account"] is None
+
+
+class TestRunDoctor:
+    def test_agent_running_and_all_keys_ok(self, manager, tmp_path):
+        key = tmp_path / "id_rsa_work"
+        key.write_text("private")
+        key.chmod(0o600)
+        manager.ssh_manager.is_ssh_agent_running.return_value = True
+        manager.config_manager.read_accounts.return_value = {
+            "work": {**WORK_ACCOUNT, "private_key": str(key)}
+        }
+        manager.ssh_manager.check_key_file.return_value = {
+            "exists": True,
+            "readable": True,
+            "permissions_ok": True,
+        }
+
+        report = manager.run_doctor()
+
+        assert report["agent_running"] is True
+        assert report["accounts"] == {
+            "work": {"exists": True, "readable": True, "permissions_ok": True}
+        }
+        manager.ssh_manager.check_key_file.assert_called_once_with(str(key))
+
+    def test_agent_not_running(self, manager):
+        manager.ssh_manager.is_ssh_agent_running.return_value = False
+        manager.config_manager.read_accounts.return_value = {}
+
+        report = manager.run_doctor()
+
+        assert report["agent_running"] is False
+        assert report["accounts"] == {}
+
+    def test_flags_account_with_no_private_key_recorded(self, manager):
+        manager.ssh_manager.is_ssh_agent_running.return_value = True
+        manager.config_manager.read_accounts.return_value = {
+            "broken": {"name": "Broken", "email": "b@co.com"}
+        }
+
+        report = manager.run_doctor()
+
+        assert report["accounts"] == {
+            "broken": {"exists": False, "readable": False, "permissions_ok": False}
+        }
+        manager.ssh_manager.check_key_file.assert_not_called()
+
+    def test_flags_missing_key_file(self, manager):
+        manager.ssh_manager.is_ssh_agent_running.return_value = True
+        manager.config_manager.read_accounts.return_value = {
+            "work": {**WORK_ACCOUNT, "private_key": "/nonexistent/id_rsa_work"}
+        }
+        manager.ssh_manager.check_key_file.return_value = {
+            "exists": False,
+            "readable": False,
+            "permissions_ok": False,
+        }
+
+        report = manager.run_doctor()
+
+        assert report["accounts"]["work"]["exists"] is False

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/tests/test_cli.py

@@ -79,6 +79,9 @@ class TestParserCommands:
     def test_verify_command(self, cli):
         assert cli.parser.parse_args(["verify"]).command == "verify"
 
+    def test_doctor_command(self, cli):
+        assert cli.parser.parse_args(["doctor"]).command == "doctor"
+
     def test_update_no_flags(self, cli):
         args = cli.parser.parse_args(["update", "mywork"])
         assert args.account_name == "mywork"
@@ -217,6 +220,75 @@ class TestHandlers:
         assert "(not set)" in out
         assert "SSH agent is not running." in out
 
+    def test_handle_doctor_all_ok(self, cli, capsys):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": True,
+            "accounts": {
+                "work": {"exists": True, "readable": True, "permissions_ok": True}
+            },
+        }
+        result = cli._handle_doctor(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 0
+        assert "SSH agent is running and reachable" in out
+        assert 'Account "work": key file OK' in out
+
+    def test_handle_doctor_agent_not_running(self, cli, capsys):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": False,
+            "accounts": {},
+        }
+        result = cli._handle_doctor(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 1
+        assert "not running or not reachable" in out
+
+    def test_handle_doctor_missing_key(self, cli, capsys):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": True,
+            "accounts": {
+                "work": {"exists": False, "readable": False, "permissions_ok": False}
+            },
+        }
+        result = cli._handle_doctor(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 1
+        assert 'Account "work": key file is missing' in out
+
+    def test_handle_doctor_unreadable_key(self, cli, capsys):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": True,
+            "accounts": {
+                "work": {"exists": True, "readable": False, "permissions_ok": False}
+            },
+        }
+        result = cli._handle_doctor(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 1
+        assert 'Account "work": key file is unreadable' in out
+
+    def test_handle_doctor_bad_permissions(self, cli, capsys):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": True,
+            "accounts": {
+                "work": {"exists": True, "readable": True, "permissions_ok": False}
+            },
+        }
+        result = cli._handle_doctor(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 1
+        assert "permissions are too permissive" in out
+
+    def test_handle_doctor_no_accounts(self, cli, capsys):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": True,
+            "accounts": {},
+        }
+        result = cli._handle_doctor(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 0
+        assert "No accounts registered yet." in out
+
     def test_handle_init_success(self, cli):
         cli.account_manager.init_repo.return_value = True
         assert cli._handle_init(argparse.Namespace(account_name="work")) == 0
@@ -355,6 +427,15 @@ class TestRun:
             result = cli.run()
         assert result == 0
 
+    def test_doctor_command_runs(self, cli):
+        cli.account_manager.run_doctor.return_value = {
+            "agent_running": True,
+            "accounts": {},
+        }
+        with patch.object(sys, "argv", ["gitacc", "doctor"]):
+            result = cli.run()
+        assert result == 0
+
 
 # ---------------------------------------------------------------------------
 # `rule` command parsing

{gitacc_switcher-1.4.0 → gitacc_switcher-1.5.0}/tests/test_ssh_manager.py

@@ -210,6 +210,50 @@ class TestGetAgentFingerprints:
             assert ssh.get_agent_fingerprints() == []
 
 
+class TestCheckKeyFile:
+    def test_missing_file(self, ssh, tmp_path):
+        result = ssh.check_key_file(str(tmp_path / "nonexistent"))
+        assert result == {
+            "exists": False,
+            "readable": False,
+            "permissions_ok": False,
+        }
+
+    def test_correct_permissions(self, ssh, tmp_path):
+        key = tmp_path / "id_rsa_test"
+        key.write_text("private key data")
+        key.chmod(0o600)
+        result = ssh.check_key_file(str(key))
+        assert result == {
+            "exists": True,
+            "readable": True,
+            "permissions_ok": True,
+        }
+
+    def test_too_permissive(self, ssh, tmp_path):
+        key = tmp_path / "id_rsa_test"
+        key.write_text("private key data")
+        key.chmod(0o644)
+        result = ssh.check_key_file(str(key))
+        assert result == {
+            "exists": True,
+            "readable": True,
+            "permissions_ok": False,
+        }
+
+    def test_unreadable_file(self, ssh, tmp_path):
+        key = tmp_path / "id_rsa_test"
+        key.write_text("private key data")
+        key.chmod(0o600)
+        with patch("os.access", return_value=False):
+            result = ssh.check_key_file(str(key))
+        assert result == {
+            "exists": True,
+            "readable": False,
+            "permissions_ok": False,
+        }
+
+
 class TestGetKeyFingerprint:
     def test_returns_fingerprint(self, ssh, tmp_path):
         pub_key = tmp_path / "id_rsa_test.pub"