gitacc-switcher 1.2.0__tar.gz → 1.3.0__tar.gz

{gitacc_switcher-1.2.0/gitacc_switcher.egg-info → gitacc_switcher-1.3.0}/PKG-INFO

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

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/gitacc_switcher/__init__.py

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

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/gitacc_switcher/account_manager.py

@@ -382,6 +382,67 @@ class AccountManager:
 
         return True
 
+    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.
+
+        Read-only: makes no changes to Git config, the SSH agent, or any
+        managed files.
+
+        Args:
+            repo_path: Path to repository (default: current directory). Used
+                to resolve local Git config when run inside a repo.
+
+        Returns:
+            Dictionary with the current name/email, the matched account name
+            (or None), whether the SSH agent is running, and which account
+            (if any) the currently loaded agent key belongs to.
+        """
+        if self.config_manager.is_git_repo(repo_path):
+            current_config = self.config_manager.get_current_git_config_local(repo_path)
+        else:
+            current_config = self.config_manager.get_current_git_config()
+
+        current_name = current_config.get("name")
+        current_email = current_config.get("email")
+
+        accounts = self.config_manager.read_accounts()
+
+        matched_account = None
+        for account_name, account_info in accounts.items():
+            if (
+                current_name
+                and current_email
+                and account_info.get("name") == current_name
+                and account_info.get("email") == current_email
+            ):
+                matched_account = account_name
+                break
+
+        agent_running = self.ssh_manager.is_ssh_agent_running()
+        agent_fingerprints = (
+            self.ssh_manager.get_agent_fingerprints() if agent_running else []
+        )
+
+        matched_key_account = None
+        if agent_fingerprints:
+            for account_name, account_info in accounts.items():
+                public_key = account_info.get("public_key")
+                if not public_key:
+                    continue
+                fingerprint = self.ssh_manager.get_key_fingerprint(public_key)
+                if fingerprint and fingerprint in agent_fingerprints:
+                    matched_key_account = account_name
+                    break
+
+        return {
+            "name": current_name,
+            "email": current_email,
+            "matched_account": matched_account,
+            "agent_running": agent_running,
+            "matched_key_account": matched_key_account,
+        }
+
     def init_repo(self, account_name: str, repo_path: Optional[Path] = None) -> bool:
         """Initialize repository with expected account and install pre-commit hook.
 

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/gitacc_switcher/cli.py

@@ -45,6 +45,7 @@ class CLI:
         self._add_switch_command(subparsers)
         self._add_list_command(subparsers)
         self._add_logout_command(subparsers)
+        self._add_status_command(subparsers)
         self._add_init_command(subparsers)
         self._add_verify_command(subparsers)
         self._add_update_command(subparsers)
@@ -74,6 +75,7 @@ Examples:
   gitacc remove myaccount       Remove an account
   gitacc list                   List all registered accounts
   gitacc logout                 Logout current account
+  gitacc status                 Show the currently active account
   gitacc init myaccount         Initialize repo with account validation
   gitacc verify                 Verify current account matches repo
   gitacc update myaccount       Update Git name for an account
@@ -158,6 +160,16 @@ Examples:
         )
         parser.set_defaults(func=self._handle_logout)
 
+    def _add_status_command(self, subparsers: argparse._SubParsersAction) -> None:
+        """Add the 'status' command parser."""
+        parser = subparsers.add_parser(
+            "status",
+            help="Show the currently active account",
+            description="Show the current Git identity and SSH agent key, "
+            "and which managed account (if any) matches",
+        )
+        parser.set_defaults(func=self._handle_status)
+
     def _add_init_command(self, subparsers: argparse._SubParsersAction) -> None:
         """Add the 'init' command parser."""
         parser = subparsers.add_parser(
@@ -396,6 +408,35 @@ Examples:
         success = self.account_manager.logout()
         return 0 if success else 1
 
+    def _handle_status(self, args: argparse.Namespace) -> int:
+        """Handle the 'status' command."""
+        status = self.account_manager.get_status()
+        name = status.get("name")
+        email = status.get("email")
+
+        echo_color("g", "Current Git identity:")
+        echo_color("g", f"  Name:  {name or '(not set)'}")
+        echo_color("g", f"  Email: {email or '(not set)'}")
+
+        matched_account = status.get("matched_account")
+        if matched_account:
+            echo_color("g", f'Matched account: "{matched_account}"')
+        else:
+            echo_color("y", "No managed account matches the current Git identity.")
+
+        if status.get("agent_running"):
+            matched_key_account = status.get("matched_key_account")
+            if matched_key_account:
+                echo_color(
+                    "g", f'SSH agent key matches account: "{matched_key_account}"'
+                )
+            else:
+                echo_color("y", "SSH agent key does not match any managed account.")
+        else:
+            echo_color("y", "SSH agent is not running.")
+
+        return 0
+
     def _handle_init(self, args: argparse.Namespace) -> int:
         """Handle the 'init' command."""
         success = self.account_manager.init_repo(args.account_name)

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/gitacc_switcher/config_manager.py

@@ -359,22 +359,37 @@ class ConfigManager:
             line = lines[i]
             if re.match(rf"^\s*\[{re.escape(account_name)}\]\s*$", line):
                 in_target_section = True
+                field_written = False
                 new_lines.append(line)
                 i += 1
                 while i < len(lines) and in_target_section:
                     if re.match(r"^\s*\[", lines[i]) and not re.match(
                         rf"^\s*\[{re.escape(account_name)}\]\s*$", lines[i]
                     ):
+                        if not field_written:
+                            # Field never appeared in this section (e.g. an
+                            # account written before this field existed) —
+                            # add it rather than silently leaving it unset.
+                            new_lines.append(f"\t{field} = {new_value}\n")
+                            field_written = True
                         in_target_section = False
                         new_lines.append(lines[i])
                         i += 1
                         break
                     elif re.match(rf"^\s*{re.escape(field)}\s*=", lines[i]):
                         new_lines.append(f"\t{field} = {new_value}\n")
+                        field_written = True
                         i += 1
                     else:
                         new_lines.append(lines[i])
                         i += 1
+                else:
+                    # Loop ended because we reached end of file, not a break —
+                    # the target section is the last one, so append here too.
+                    if in_target_section and not field_written:
+                        new_lines.append(f"\t{field} = {new_value}\n")
+                        field_written = True
+                    in_target_section = False
             else:
                 new_lines.append(line)
                 i += 1

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/gitacc_switcher/ssh_manager.py

@@ -6,7 +6,7 @@ import subprocess
 import tempfile
 import re
 from pathlib import Path
-from typing import Optional, Tuple
+from typing import List, Optional, Tuple
 
 
 class SSHManager:
@@ -221,6 +221,54 @@ class SSHManager:
                 "ssh-add command not found. Please ensure SSH tools are installed.",
             )
 
+    def get_agent_fingerprints(self) -> List[str]:
+        """Get fingerprints of keys currently loaded in the SSH agent.
+
+        Read-only; does not modify the agent.
+
+        Returns:
+            List of fingerprint strings (e.g. "SHA256:abc..."). Empty if the
+            agent is not running, has no keys loaded, or can't be reached.
+        """
+        try:
+            result = subprocess.run(["ssh-add", "-l"], capture_output=True, text=True)
+        except FileNotFoundError:
+            return []
+
+        if result.returncode != 0:
+            return []
+
+        fingerprints = []
+        for line in result.stdout.strip().split("\n"):
+            parts = line.strip().split()
+            if len(parts) >= 2:
+                fingerprints.append(parts[1])
+        return fingerprints
+
+    def get_key_fingerprint(self, public_key_path: str) -> Optional[str]:
+        """Get the fingerprint of a public key file.
+
+        Args:
+            public_key_path: Path to the public key file
+
+        Returns:
+            Fingerprint string (e.g. "SHA256:abc...") or None on error
+        """
+        try:
+            result = subprocess.run(
+                ["ssh-keygen", "-lf", str(public_key_path)],
+                capture_output=True,
+                text=True,
+            )
+        except FileNotFoundError:
+            return None
+
+        if result.returncode != 0:
+            return None
+
+        parts = result.stdout.strip().split()
+        return parts[1] if len(parts) >= 2 else None
+
     def get_public_key_content(self, public_key_path: str) -> Optional[str]:
         """Read public key content.
 

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0/gitacc_switcher.egg-info}/PKG-INFO

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

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/pyproject.toml

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

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/setup.py

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

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/tests/test_account_manager.py

@@ -426,3 +426,108 @@ class TestAddAccount:
         assert result is True
         _, kwargs = manager.config_manager.add_account.call_args
         assert kwargs["sign"] is False
+
+
+class TestGetStatus:
+    def test_matches_account_by_identity(self, manager):
+        manager.config_manager.is_git_repo.return_value = False
+        manager.config_manager.get_current_git_config.return_value = {
+            "name": "Work User",
+            "email": "work@company.com",
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = False
+
+        status = manager.get_status()
+
+        assert status["name"] == "Work User"
+        assert status["email"] == "work@company.com"
+        assert status["matched_account"] == "work"
+        assert status["agent_running"] is False
+        assert status["matched_key_account"] is None
+
+    def test_no_match_when_identity_unknown(self, manager):
+        manager.config_manager.is_git_repo.return_value = False
+        manager.config_manager.get_current_git_config.return_value = {
+            "name": "Someone Else",
+            "email": "someone@else.com",
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = False
+
+        status = manager.get_status()
+
+        assert status["matched_account"] is None
+
+    def test_no_match_when_identity_unset(self, manager):
+        manager.config_manager.is_git_repo.return_value = False
+        manager.config_manager.get_current_git_config.return_value = {
+            "name": None,
+            "email": None,
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = False
+
+        status = manager.get_status()
+
+        assert status["matched_account"] is None
+
+    def test_uses_local_git_config_inside_repo(self, manager):
+        manager.config_manager.is_git_repo.return_value = True
+        manager.config_manager.get_current_git_config_local.return_value = {
+            "name": "Work User",
+            "email": "work@company.com",
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = False
+
+        status = manager.get_status()
+
+        manager.config_manager.get_current_git_config_local.assert_called_once()
+        manager.config_manager.get_current_git_config.assert_not_called()
+        assert status["matched_account"] == "work"
+
+    def test_matches_account_by_agent_key_fingerprint(self, manager):
+        manager.config_manager.is_git_repo.return_value = False
+        manager.config_manager.get_current_git_config.return_value = {
+            "name": None,
+            "email": None,
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = True
+        manager.ssh_manager.get_agent_fingerprints.return_value = ["SHA256:abc123"]
+        manager.ssh_manager.get_key_fingerprint.return_value = "SHA256:abc123"
+
+        status = manager.get_status()
+
+        assert status["agent_running"] is True
+        assert status["matched_key_account"] == "work"
+
+    def test_no_key_match_when_fingerprints_differ(self, manager):
+        manager.config_manager.is_git_repo.return_value = False
+        manager.config_manager.get_current_git_config.return_value = {
+            "name": None,
+            "email": None,
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = True
+        manager.ssh_manager.get_agent_fingerprints.return_value = ["SHA256:other"]
+        manager.ssh_manager.get_key_fingerprint.return_value = "SHA256:abc123"
+
+        status = manager.get_status()
+
+        assert status["matched_key_account"] is None
+
+    def test_no_key_lookup_when_agent_not_running(self, manager):
+        manager.config_manager.is_git_repo.return_value = False
+        manager.config_manager.get_current_git_config.return_value = {
+            "name": None,
+            "email": None,
+        }
+        manager.config_manager.read_accounts.return_value = {"work": WORK_ACCOUNT}
+        manager.ssh_manager.is_ssh_agent_running.return_value = False
+
+        status = manager.get_status()
+
+        manager.ssh_manager.get_agent_fingerprints.assert_not_called()
+        assert status["matched_key_account"] is None

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/tests/test_cli.py

@@ -69,6 +69,9 @@ class TestParserCommands:
     def test_logout_command(self, cli):
         assert cli.parser.parse_args(["logout"]).command == "logout"
 
+    def test_status_command(self, cli):
+        assert cli.parser.parse_args(["status"]).command == "status"
+
     def test_init_parses_account(self, cli):
         args = cli.parser.parse_args(["init", "mywork"])
         assert args.account_name == "mywork"
@@ -170,6 +173,50 @@ class TestHandlers:
         cli.account_manager.verify_account.return_value = False
         assert cli._handle_verify(argparse.Namespace()) == 1
 
+    def test_handle_status_matched(self, cli, capsys):
+        cli.account_manager.get_status.return_value = {
+            "name": "Work User",
+            "email": "work@co.com",
+            "matched_account": "work",
+            "agent_running": True,
+            "matched_key_account": "work",
+        }
+        result = cli._handle_status(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 0
+        assert "Work User" in out
+        assert "work@co.com" in out
+        assert 'Matched account: "work"' in out
+        assert 'SSH agent key matches account: "work"' in out
+
+    def test_handle_status_no_match(self, cli, capsys):
+        cli.account_manager.get_status.return_value = {
+            "name": "Someone",
+            "email": "someone@else.com",
+            "matched_account": None,
+            "agent_running": True,
+            "matched_key_account": None,
+        }
+        result = cli._handle_status(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 0
+        assert "No managed account matches" in out
+        assert "does not match any managed account" in out
+
+    def test_handle_status_no_identity_set(self, cli, capsys):
+        cli.account_manager.get_status.return_value = {
+            "name": None,
+            "email": None,
+            "matched_account": None,
+            "agent_running": False,
+            "matched_key_account": None,
+        }
+        result = cli._handle_status(argparse.Namespace())
+        out = capsys.readouterr().out
+        assert result == 0
+        assert "(not set)" in out
+        assert "SSH agent is not running." 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
@@ -295,3 +342,15 @@ class TestRun:
         with patch.object(sys, "argv", ["gitacc", "logout"]):
             result = cli.run()
         assert result == 0
+
+    def test_status_command_runs(self, cli):
+        cli.account_manager.get_status.return_value = {
+            "name": None,
+            "email": None,
+            "matched_account": None,
+            "agent_running": False,
+            "matched_key_account": None,
+        }
+        with patch.object(sys, "argv", ["gitacc", "status"]):
+            result = cli.run()
+        assert result == 0

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/tests/test_config_manager.py

@@ -164,6 +164,27 @@ class TestUpdateAccountField:
     def test_returns_false_for_missing_account(self, config_with_accounts):
         assert config_with_accounts.update_account_field("nobody", "name", "X") is False
 
+    def test_appends_field_missing_from_section(self, config_with_accounts):
+        # SAMPLE_GITACC accounts have no "sign" field — this reproduces a pre-1.2.0
+        # account whose section was written before that field existed.
+        assert "sign" not in config_with_accounts.get_account("work")
+        assert config_with_accounts.update_account_field("work", "sign", "true") is True
+        assert config_with_accounts.get_account("work")["sign"] == "true"
+
+    def test_appending_missing_field_preserves_other_fields(self, config_with_accounts):
+        config_with_accounts.update_account_field("work", "sign", "true")
+        account = config_with_accounts.get_account("work")
+        assert account["name"] == "Work User"
+        assert account["email"] == "work@company.com"
+        assert account["private_key"] == "/home/user/.ssh/id_rsa_work"
+        assert account["public_key"] == "/home/user/.ssh/id_rsa_work.pub"
+
+    def test_appending_missing_field_does_not_affect_other_account(
+        self, config_with_accounts
+    ):
+        config_with_accounts.update_account_field("work", "sign", "true")
+        assert "sign" not in config_with_accounts.get_account("personal")
+
 
 class TestListAccountNames:
     def test_empty(self, config):

{gitacc_switcher-1.2.0 → gitacc_switcher-1.3.0}/tests/test_ssh_manager.py

@@ -183,3 +183,51 @@ class TestGetPublicKeyContent:
 
     def test_returns_none_for_missing_file(self, ssh, tmp_path):
         assert ssh.get_public_key_content(str(tmp_path / "nonexistent.pub")) is None
+
+
+class TestGetAgentFingerprints:
+    def test_returns_fingerprints_for_loaded_keys(self, ssh):
+        output = (
+            "2048 SHA256:abc123 work@co.com (RSA)\n"
+            "256 SHA256:def456 personal@co.com (ED25519)\n"
+        )
+        with patch(
+            "subprocess.run",
+            return_value=MagicMock(returncode=0, stdout=output),
+        ):
+            fingerprints = ssh.get_agent_fingerprints()
+        assert fingerprints == ["SHA256:abc123", "SHA256:def456"]
+
+    def test_returns_empty_when_agent_has_no_keys(self, ssh):
+        with patch(
+            "subprocess.run",
+            return_value=MagicMock(returncode=1, stdout=""),
+        ):
+            assert ssh.get_agent_fingerprints() == []
+
+    def test_returns_empty_when_ssh_add_missing(self, ssh):
+        with patch("subprocess.run", side_effect=FileNotFoundError):
+            assert ssh.get_agent_fingerprints() == []
+
+
+class TestGetKeyFingerprint:
+    def test_returns_fingerprint(self, ssh, tmp_path):
+        pub_key = tmp_path / "id_rsa_test.pub"
+        pub_key.write_text("ssh-rsa AAAA test@test.com")
+        with patch(
+            "subprocess.run",
+            return_value=MagicMock(
+                returncode=0, stdout="2048 SHA256:abc123 test@test.com (RSA)\n"
+            ),
+        ):
+            assert ssh.get_key_fingerprint(str(pub_key)) == "SHA256:abc123"
+
+    def test_returns_none_on_failure(self, ssh, tmp_path):
+        pub_key = tmp_path / "id_rsa_test.pub"
+        with patch("subprocess.run", return_value=MagicMock(returncode=1, stdout="")):
+            assert ssh.get_key_fingerprint(str(pub_key)) is None
+
+    def test_returns_none_when_ssh_keygen_missing(self, ssh, tmp_path):
+        pub_key = tmp_path / "id_rsa_test.pub"
+        with patch("subprocess.run", side_effect=FileNotFoundError):
+            assert ssh.get_key_fingerprint(str(pub_key)) is None