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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.4.0
+Version: 1.6.0
 Summary: Git Account Switcher - Manage multiple Git SSH accounts easily
 Home-page: https://github.com/ktechhub/gitacc_switcher
 Author: ktechhub
@@ -50,6 +50,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Colored terminal output with active account indicator
 - Pre-commit hook to prevent commits with the wrong account
 - Opt-in directory-based auto-switching (`gitacc rule`) with a bash/zsh shell hook
+- Per-account SSH config `Host` aliases (`gitacc alias`) for `git@<alias>:org/repo` clone URLs
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -219,6 +220,29 @@ The hook is silent unless it actually needs to switch accounts: no matching rule
 that isn't running, or an identity that's already correct all do nothing. This is entirely
 opt-in — `gitacc rule add` alone never touches your shell config.
 
+### `gitacc alias add <account> <host-alias> [--hostname HOSTNAME] [--user USER]` / `gitacc alias remove <host-alias>` / `gitacc alias list`
+
+Bind an SSH config `Host` alias to an account's key by writing a clearly delimited, safely
+add/updatable/removable block to `~/.ssh/config`. This lets you clone/push via a per-account host
+alias (e.g. `git@github-work:org/repo`) without hand-editing your SSH config, and without the
+account's key needing to be loaded into the SSH agent at all.
+
+```bash
+gitacc alias add work github-work                          # git@github-work:org/repo uses "work"'s key
+gitacc alias add personal github-personal --hostname github.com
+gitacc alias list
+gitacc alias remove github-work
+```
+
+`--hostname` defaults to `github.com` and `--user` defaults to `git`. Running `alias add` again
+for the same alias updates it in place; everything else already in `~/.ssh/config` (including
+aliases for other accounts) is left untouched.
+
+```bash
+# clone using the "work" account's key, without ever switching the active identity
+git clone git@github-work:myorg/myrepo.git
+```
+
 ### `gitacc autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -250,6 +274,7 @@ gitacc --version
 | `~/.gitaccrules` | Directory → account rules for `gitacc rule` (opt-in auto-switch) |
 | `~/.ssh/id_<type>_<account>` | Private SSH key per account |
 | `~/.ssh/id_<type>_<account>.pub` | Public SSH key per account |
+| `~/.ssh/config` | Holds gitacc-managed `Host` alias blocks (`gitacc alias`), clearly delimited from any other entries |
 
 `~/.gitacc` format:
 

{gitacc_switcher-1.4.0 → gitacc_switcher-1.6.0}/README.md

@@ -17,6 +17,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Colored terminal output with active account indicator
 - Pre-commit hook to prevent commits with the wrong account
 - Opt-in directory-based auto-switching (`gitacc rule`) with a bash/zsh shell hook
+- Per-account SSH config `Host` aliases (`gitacc alias`) for `git@<alias>:org/repo` clone URLs
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -186,6 +187,29 @@ The hook is silent unless it actually needs to switch accounts: no matching rule
 that isn't running, or an identity that's already correct all do nothing. This is entirely
 opt-in — `gitacc rule add` alone never touches your shell config.
 
+### `gitacc alias add <account> <host-alias> [--hostname HOSTNAME] [--user USER]` / `gitacc alias remove <host-alias>` / `gitacc alias list`
+
+Bind an SSH config `Host` alias to an account's key by writing a clearly delimited, safely
+add/updatable/removable block to `~/.ssh/config`. This lets you clone/push via a per-account host
+alias (e.g. `git@github-work:org/repo`) without hand-editing your SSH config, and without the
+account's key needing to be loaded into the SSH agent at all.
+
+```bash
+gitacc alias add work github-work                          # git@github-work:org/repo uses "work"'s key
+gitacc alias add personal github-personal --hostname github.com
+gitacc alias list
+gitacc alias remove github-work
+```
+
+`--hostname` defaults to `github.com` and `--user` defaults to `git`. Running `alias add` again
+for the same alias updates it in place; everything else already in `~/.ssh/config` (including
+aliases for other accounts) is left untouched.
+
+```bash
+# clone using the "work" account's key, without ever switching the active identity
+git clone git@github-work:myorg/myrepo.git
+```
+
 ### `gitacc autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -217,6 +241,7 @@ gitacc --version
 | `~/.gitaccrules` | Directory → account rules for `gitacc rule` (opt-in auto-switch) |
 | `~/.ssh/id_<type>_<account>` | Private SSH key per account |
 | `~/.ssh/id_<type>_<account>.pub` | Public SSH key per account |
+| `~/.ssh/config` | Holds gitacc-managed `Host` alias blocks (`gitacc alias`), clearly delimited from any other entries |
 
 `~/.gitacc` format:
 

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

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

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

@@ -384,6 +384,101 @@ class AccountManager:
 
         return True
 
+    def add_host_alias(
+        self,
+        account_name: str,
+        host_alias: str,
+        hostname: str = "github.com",
+        ssh_user: str = "git",
+    ) -> bool:
+        """Bind an SSH config `Host` alias to an account's key.
+
+        Args:
+            account_name: Account whose key the alias should use
+            host_alias: The `Host` alias to create/update (e.g. "github-work")
+            hostname: Real host to connect to (default: "github.com")
+            ssh_user: SSH user for the connection (default: "git")
+
+        Returns:
+            True if successful, False otherwise
+        """
+        account_info = self.config_manager.get_account(account_name)
+        if not account_info:
+            echo_color("r", f'Account "{account_name}" not found!')
+            return False
+
+        private_key = account_info.get("private_key")
+        if not private_key:
+            echo_color("r", f'Account "{account_name}" has no private key on record!')
+            return False
+
+        success = self.ssh_manager.add_host_alias(
+            host_alias, hostname, private_key, ssh_user
+        )
+        if success:
+            echo_color(
+                "g",
+                f'Host alias "{host_alias}" → account "{account_name}" '
+                f"({ssh_user}@{hostname})",
+            )
+        else:
+            echo_color("r", f'Failed to write host alias "{host_alias}"!')
+        return success
+
+    def remove_host_alias(self, host_alias: str) -> bool:
+        """Remove a managed SSH config host alias.
+
+        Args:
+            host_alias: The `Host` alias to remove
+
+        Returns:
+            True if a block was found and removed, False otherwise
+        """
+        success = self.ssh_manager.remove_host_alias(host_alias)
+        if success:
+            echo_color("g", f'Host alias "{host_alias}" removed.')
+        else:
+            echo_color("y", f'No managed host alias "{host_alias}" was found.')
+        return success
+
+    def list_host_aliases(self) -> Dict[str, Dict[str, str]]:
+        """List all gitacc-managed SSH config host aliases.
+
+        Returns:
+            Dictionary mapping host alias to its hostname, ssh user, and
+            identity file path.
+        """
+        return self.ssh_manager.list_host_aliases()
+
+    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.6.0}/gitacc_switcher/cli.py

@@ -48,11 +48,13 @@ 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)
         self._add_autocomplete_command(subparsers)
         self._add_rule_command(subparsers)
+        self._add_alias_command(subparsers)
 
         # Include account names in top-level completion so `gitacc <TAB>` works for
         # the `gitacc <account>` shorthand, not just for subcommand names.
@@ -79,11 +81,14 @@ 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
   gitacc rule add work ~/work   Auto-switch to "work" inside that directory
   gitacc rule hook bash         Print the shell hook (add to ~/.bashrc)
+  gitacc alias add work github-work   Bind a Host alias to an account's key
+  gitacc alias list             List managed SSH config host aliases
         """
 
     def _add_add_command(self, subparsers: argparse._SubParsersAction) -> None:
@@ -175,6 +180,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(
@@ -333,6 +349,65 @@ Examples:
         )
         check_parser.set_defaults(func=self._handle_rule_check)
 
+    def _add_alias_command(self, subparsers: argparse._SubParsersAction) -> None:
+        """Add the 'alias' command parser for SSH config Host aliases."""
+        parser = subparsers.add_parser(
+            "alias",
+            help="Manage per-account SSH config Host aliases",
+            description="Add, remove, and list managed Host alias blocks in "
+            "~/.ssh/config, so you can clone/push via e.g. "
+            "git@<alias>:org/repo using a specific account's key",
+        )
+        alias_subparsers = parser.add_subparsers(
+            dest="alias_command",
+            help="Alias commands",
+        )
+
+        add_parser = alias_subparsers.add_parser(
+            "add",
+            help="Add or update a Host alias for an account",
+            description="Bind an SSH config Host alias to an account's key",
+        )
+        account_arg = add_parser.add_argument(
+            "account_name",
+            help="Account whose key the alias should use",
+        )
+        add_parser.add_argument(
+            "host_alias",
+            help="Host alias to create/update (e.g. github-work)",
+        )
+        add_parser.add_argument(
+            "--hostname",
+            dest="hostname",
+            default="github.com",
+            help="Real host to connect to (default: github.com)",
+        )
+        add_parser.add_argument(
+            "--user",
+            dest="ssh_user",
+            default="git",
+            help="SSH user for the connection (default: git)",
+        )
+        if argcomplete:
+            account_arg.completer = lambda **kwargs: get_account_names()
+        add_parser.set_defaults(func=self._handle_alias_add)
+
+        remove_parser = alias_subparsers.add_parser(
+            "remove",
+            help="Remove a Host alias",
+        )
+        remove_parser.add_argument(
+            "host_alias",
+            help="Host alias to remove",
+        )
+        remove_parser.set_defaults(func=self._handle_alias_remove)
+
+        list_parser = alias_subparsers.add_parser(
+            "list",
+            help="List all managed Host aliases",
+        )
+        list_parser.set_defaults(func=self._handle_alias_list)
+
     def _handle_autocomplete_install(self, args: argparse.Namespace) -> int:
         """Handle the 'autocomplete install' command."""
         if not argcomplete:
@@ -516,6 +591,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)
@@ -610,6 +719,33 @@ Examples:
         success = self.account_manager.switch_account(account_name)
         return 0 if success else 1
 
+    def _handle_alias_add(self, args: argparse.Namespace) -> int:
+        """Handle the 'alias add' command."""
+        success = self.account_manager.add_host_alias(
+            args.account_name, args.host_alias, args.hostname, args.ssh_user
+        )
+        return 0 if success else 1
+
+    def _handle_alias_remove(self, args: argparse.Namespace) -> int:
+        """Handle the 'alias remove' command."""
+        success = self.account_manager.remove_host_alias(args.host_alias)
+        return 0 if success else 1
+
+    def _handle_alias_list(self, args: argparse.Namespace) -> int:
+        """Handle the 'alias list' command."""
+        aliases = self.account_manager.list_host_aliases()
+        if not aliases:
+            echo_color("y", "No managed host aliases yet.")
+            return 0
+
+        echo_color("g", "Managed SSH config host aliases:")
+        for host_alias, info in aliases.items():
+            print(
+                f"  {host_alias} → {info['user']}@{info['hostname']} "
+                f"({info['identity_file']})"
+            )
+        return 0
+
     def _handle_account_name_shortcut(self, account_name: str) -> int:
         """Handle account name as shortcut for switch command."""
         success = self.account_manager.switch_account(account_name)

{gitacc_switcher-1.4.0 → gitacc_switcher-1.6.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.
 
@@ -283,3 +309,166 @@ class SSHManager:
                 return f.read().strip()
         except Exception:
             return None
+
+    def get_ssh_config_path(self) -> Path:
+        """Get the path to the user's SSH config file (~/.ssh/config)."""
+        return self.ssh_dir / "config"
+
+    @staticmethod
+    def _host_alias_markers(host_alias: str) -> Tuple[str, str]:
+        """Begin/end marker lines that delimit a managed host-alias block.
+
+        Keyed by host_alias so each alias's block can be found, replaced, or
+        removed independently without touching anything else in the file.
+        """
+        return (
+            f"# >>> gitacc-switcher host-alias: {host_alias} >>>",
+            f"# <<< gitacc-switcher host-alias: {host_alias} <<<",
+        )
+
+    def _build_host_alias_block(
+        self, host_alias: str, hostname: str, private_key_path: str, ssh_user: str
+    ) -> str:
+        start, end = self._host_alias_markers(host_alias)
+        lines = [
+            start,
+            f"Host {host_alias}",
+            f"    HostName {hostname}",
+            f"    User {ssh_user}",
+            f"    IdentityFile {private_key_path}",
+            "    IdentitiesOnly yes",
+            end,
+        ]
+        return "\n".join(lines) + "\n"
+
+    def _read_ssh_config(self) -> str:
+        config_path = self.get_ssh_config_path()
+        if not config_path.exists():
+            return ""
+        return config_path.read_text()
+
+    def has_host_alias(self, host_alias: str) -> bool:
+        """Check whether a managed host-alias block already exists.
+
+        Args:
+            host_alias: The `Host` alias to look for (e.g. "github-work")
+
+        Returns:
+            True if a gitacc-managed block for this alias is present
+        """
+        start, _ = self._host_alias_markers(host_alias)
+        return start in self._read_ssh_config()
+
+    def add_host_alias(
+        self,
+        host_alias: str,
+        hostname: str,
+        private_key_path: str,
+        ssh_user: str = "git",
+    ) -> bool:
+        """Add or update a managed SSH config `Host` alias block.
+
+        Writes a clearly delimited block to ~/.ssh/config pointing the alias
+        at the given key, so the user can clone/push via e.g.
+        `git@<host_alias>:org/repo` without hand-editing their SSH config.
+        Safe to call again for the same alias: only the block between its
+        own markers is replaced, leaving the rest of the file untouched.
+
+        Args:
+            host_alias: The `Host` alias to create/update (e.g. "github-work")
+            hostname: Real host to connect to (e.g. "github.com")
+            private_key_path: Path to the account's private SSH key
+            ssh_user: SSH user for the connection (default: "git")
+
+        Returns:
+            True if successful, False otherwise
+        """
+        start, end = self._host_alias_markers(host_alias)
+        block = self._build_host_alias_block(
+            host_alias, hostname, private_key_path, ssh_user
+        )
+        existing = self._read_ssh_config()
+
+        pattern = re.compile(
+            rf"^{re.escape(start)}\n.*?^{re.escape(end)}\n?",
+            re.MULTILINE | re.DOTALL,
+        )
+        if pattern.search(existing):
+            new_content = pattern.sub(block, existing, count=1)
+        else:
+            new_content = existing
+            if new_content and not new_content.endswith("\n"):
+                new_content += "\n"
+            if new_content and not new_content.endswith("\n\n"):
+                new_content += "\n"
+            new_content += block
+
+        try:
+            config_path = self.get_ssh_config_path()
+            is_new_file = not config_path.exists()
+            config_path.write_text(new_content)
+            if is_new_file:
+                config_path.chmod(0o600)
+            return True
+        except OSError:
+            return False
+
+    def remove_host_alias(self, host_alias: str) -> bool:
+        """Remove a managed SSH config `Host` alias block, if present.
+
+        Only the block delimited by this alias's own markers is removed;
+        everything else in ~/.ssh/config is left exactly as it was.
+
+        Args:
+            host_alias: The `Host` alias to remove
+
+        Returns:
+            True if a block was found and removed, False if none existed or
+            on error
+        """
+        start, end = self._host_alias_markers(host_alias)
+        existing = self._read_ssh_config()
+
+        pattern = re.compile(
+            rf"\n?^{re.escape(start)}\n.*?^{re.escape(end)}\n?",
+            re.MULTILINE | re.DOTALL,
+        )
+        new_content, count = pattern.subn("", existing)
+        if count == 0:
+            return False
+
+        try:
+            self.get_ssh_config_path().write_text(new_content)
+            return True
+        except OSError:
+            return False
+
+    def list_host_aliases(self) -> Dict[str, Dict[str, str]]:
+        """List all gitacc-managed SSH config host aliases.
+
+        Read-only; does not modify anything.
+
+        Returns:
+            Dictionary mapping host alias to its hostname, ssh user, and
+            identity file path.
+        """
+        existing = self._read_ssh_config()
+        pattern = re.compile(
+            r"^# >>> gitacc-switcher host-alias: (?P<alias>.+?) >>>\n"
+            r"Host .+?\n"
+            r"\s*HostName (?P<hostname>.+?)\n"
+            r"\s*User (?P<user>.+?)\n"
+            r"\s*IdentityFile (?P<identity>.+?)\n"
+            r"\s*IdentitiesOnly yes\n"
+            r"# <<< gitacc-switcher host-alias: (?P=alias) <<<",
+            re.MULTILINE,
+        )
+
+        aliases = {}
+        for match in pattern.finditer(existing):
+            aliases[match.group("alias")] = {
+                "hostname": match.group("hostname"),
+                "user": match.group("user"),
+                "identity_file": match.group("identity"),
+            }
+        return aliases

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacc-switcher
-Version: 1.4.0
+Version: 1.6.0
 Summary: Git Account Switcher - Manage multiple Git SSH accounts easily
 Home-page: https://github.com/ktechhub/gitacc_switcher
 Author: ktechhub
@@ -50,6 +50,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Colored terminal output with active account indicator
 - Pre-commit hook to prevent commits with the wrong account
 - Opt-in directory-based auto-switching (`gitacc rule`) with a bash/zsh shell hook
+- Per-account SSH config `Host` aliases (`gitacc alias`) for `git@<alias>:org/repo` clone URLs
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -219,6 +220,29 @@ The hook is silent unless it actually needs to switch accounts: no matching rule
 that isn't running, or an identity that's already correct all do nothing. This is entirely
 opt-in — `gitacc rule add` alone never touches your shell config.
 
+### `gitacc alias add <account> <host-alias> [--hostname HOSTNAME] [--user USER]` / `gitacc alias remove <host-alias>` / `gitacc alias list`
+
+Bind an SSH config `Host` alias to an account's key by writing a clearly delimited, safely
+add/updatable/removable block to `~/.ssh/config`. This lets you clone/push via a per-account host
+alias (e.g. `git@github-work:org/repo`) without hand-editing your SSH config, and without the
+account's key needing to be loaded into the SSH agent at all.
+
+```bash
+gitacc alias add work github-work                          # git@github-work:org/repo uses "work"'s key
+gitacc alias add personal github-personal --hostname github.com
+gitacc alias list
+gitacc alias remove github-work
+```
+
+`--hostname` defaults to `github.com` and `--user` defaults to `git`. Running `alias add` again
+for the same alias updates it in place; everything else already in `~/.ssh/config` (including
+aliases for other accounts) is left untouched.
+
+```bash
+# clone using the "work" account's key, without ever switching the active identity
+git clone git@github-work:myorg/myrepo.git
+```
+
 ### `gitacc autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -250,6 +274,7 @@ gitacc --version
 | `~/.gitaccrules` | Directory → account rules for `gitacc rule` (opt-in auto-switch) |
 | `~/.ssh/id_<type>_<account>` | Private SSH key per account |
 | `~/.ssh/id_<type>_<account>.pub` | Public SSH key per account |
+| `~/.ssh/config` | Holds gitacc-managed `Host` alias blocks (`gitacc alias`), clearly delimited from any other entries |
 
 `~/.gitacc` format:
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacc-switcher"
-version = "1.4.0"
+version = "1.6.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.6.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.6.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.6.0}/tests/test_account_manager.py

@@ -531,3 +531,125 @@ 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
+
+
+class TestAddHostAlias:
+    def test_fails_when_account_not_found(self, manager):
+        manager.config_manager.get_account.return_value = None
+        assert manager.add_host_alias("nobody", "github-work") is False
+        manager.ssh_manager.add_host_alias.assert_not_called()
+
+    def test_fails_when_account_has_no_private_key(self, manager):
+        manager.config_manager.get_account.return_value = {"email": "w@co.com"}
+        assert manager.add_host_alias("work", "github-work") is False
+        manager.ssh_manager.add_host_alias.assert_not_called()
+
+    def test_success_uses_defaults(self, manager):
+        manager.config_manager.get_account.return_value = WORK_ACCOUNT
+        manager.ssh_manager.add_host_alias.return_value = True
+
+        assert manager.add_host_alias("work", "github-work") is True
+
+        manager.ssh_manager.add_host_alias.assert_called_once_with(
+            "github-work", "github.com", WORK_ACCOUNT["private_key"], "git"
+        )
+
+    def test_success_with_custom_hostname_and_user(self, manager):
+        manager.config_manager.get_account.return_value = WORK_ACCOUNT
+        manager.ssh_manager.add_host_alias.return_value = True
+
+        result = manager.add_host_alias(
+            "work", "gitlab-work", hostname="gitlab.com", ssh_user="deploy"
+        )
+
+        assert result is True
+        manager.ssh_manager.add_host_alias.assert_called_once_with(
+            "gitlab-work", "gitlab.com", WORK_ACCOUNT["private_key"], "deploy"
+        )
+
+    def test_returns_false_when_ssh_manager_fails(self, manager):
+        manager.config_manager.get_account.return_value = WORK_ACCOUNT
+        manager.ssh_manager.add_host_alias.return_value = False
+        assert manager.add_host_alias("work", "github-work") is False
+
+
+class TestRemoveHostAlias:
+    def test_success(self, manager):
+        manager.ssh_manager.remove_host_alias.return_value = True
+        assert manager.remove_host_alias("github-work") is True
+
+    def test_not_found(self, manager):
+        manager.ssh_manager.remove_host_alias.return_value = False
+        assert manager.remove_host_alias("nonexistent") is False
+
+
+class TestListHostAliases:
+    def test_delegates_to_ssh_manager(self, manager):
+        data = {"github-work": {"hostname": "github.com"}}
+        manager.ssh_manager.list_host_aliases.return_value = data
+        assert manager.list_host_aliases() == data
+
+    def test_empty(self, manager):
+        manager.ssh_manager.list_host_aliases.return_value = {}
+        assert manager.list_host_aliases() == {}

{gitacc_switcher-1.4.0 → gitacc_switcher-1.6.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
@@ -494,3 +575,102 @@ class TestRuleHandlers:
         cli.account_manager.ssh_manager.is_ssh_agent_running.return_value = True
         cli.account_manager.switch_account.return_value = False
         assert cli._handle_rule_check(argparse.Namespace()) == 1
+
+
+# ---------------------------------------------------------------------------
+# `alias` command parsing
+# ---------------------------------------------------------------------------
+
+
+class TestAliasCommandParsing:
+    def test_alias_add_parses_defaults(self, cli):
+        args = cli.parser.parse_args(["alias", "add", "work", "github-work"])
+        assert args.command == "alias"
+        assert args.alias_command == "add"
+        assert args.account_name == "work"
+        assert args.host_alias == "github-work"
+        assert args.hostname == "github.com"
+        assert args.ssh_user == "git"
+
+    def test_alias_add_parses_custom_hostname_and_user(self, cli):
+        args = cli.parser.parse_args(
+            [
+                "alias",
+                "add",
+                "work",
+                "gitlab-work",
+                "--hostname",
+                "gitlab.com",
+                "--user",
+                "deploy",
+            ]
+        )
+        assert args.hostname == "gitlab.com"
+        assert args.ssh_user == "deploy"
+
+    def test_alias_remove_parses_host_alias(self, cli):
+        args = cli.parser.parse_args(["alias", "remove", "github-work"])
+        assert args.alias_command == "remove"
+        assert args.host_alias == "github-work"
+
+    def test_alias_list_command(self, cli):
+        args = cli.parser.parse_args(["alias", "list"])
+        assert args.alias_command == "list"
+
+
+# ---------------------------------------------------------------------------
+# `alias` command handlers
+# ---------------------------------------------------------------------------
+
+
+class TestAliasCommandHandlers:
+    def test_handle_alias_add_success(self, cli):
+        args = argparse.Namespace(
+            account_name="work",
+            host_alias="github-work",
+            hostname="github.com",
+            ssh_user="git",
+        )
+        cli.account_manager.add_host_alias.return_value = True
+        assert cli._handle_alias_add(args) == 0
+        cli.account_manager.add_host_alias.assert_called_once_with(
+            "work", "github-work", "github.com", "git"
+        )
+
+    def test_handle_alias_add_failure(self, cli):
+        args = argparse.Namespace(
+            account_name="nobody",
+            host_alias="github-work",
+            hostname="github.com",
+            ssh_user="git",
+        )
+        cli.account_manager.add_host_alias.return_value = False
+        assert cli._handle_alias_add(args) == 1
+
+    def test_handle_alias_remove_success(self, cli):
+        cli.account_manager.remove_host_alias.return_value = True
+        args = argparse.Namespace(host_alias="github-work")
+        assert cli._handle_alias_remove(args) == 0
+
+    def test_handle_alias_remove_not_found(self, cli):
+        cli.account_manager.remove_host_alias.return_value = False
+        args = argparse.Namespace(host_alias="nonexistent")
+        assert cli._handle_alias_remove(args) == 1
+
+    def test_handle_alias_list_empty(self, cli):
+        cli.account_manager.list_host_aliases.return_value = {}
+        assert cli._handle_alias_list(argparse.Namespace()) == 0
+
+    def test_handle_alias_list_with_aliases(self, cli, capsys):
+        cli.account_manager.list_host_aliases.return_value = {
+            "github-work": {
+                "hostname": "github.com",
+                "user": "git",
+                "identity_file": "/home/u/.ssh/id_work",
+            }
+        }
+        result = cli._handle_alias_list(argparse.Namespace())
+        assert result == 0
+        out = capsys.readouterr().out
+        assert "github-work" in out
+        assert "git@github.com" in out

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

@@ -210,6 +210,163 @@ 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 TestHostAlias:
+    def test_add_creates_config_file(self, ssh):
+        config_path = ssh.get_ssh_config_path()
+        assert not config_path.exists()
+
+        assert ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        assert config_path.exists()
+        content = config_path.read_text()
+        assert "Host github-work" in content
+        assert "HostName github.com" in content
+        assert "IdentityFile /home/u/.ssh/id_work" in content
+        assert "User git" in content
+        assert "IdentitiesOnly yes" in content
+
+    def test_add_sets_restrictive_permissions_on_new_file(self, ssh):
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        mode = ssh.get_ssh_config_path().stat().st_mode & 0o777
+        assert mode == 0o600
+
+    def test_add_uses_custom_user(self, ssh):
+        ssh.add_host_alias(
+            "gitlab-work", "gitlab.com", "/home/u/.ssh/id_work", ssh_user="deploy"
+        )
+        assert "User deploy" in ssh.get_ssh_config_path().read_text()
+
+    def test_add_preserves_unrelated_existing_content(self, ssh):
+        config_path = ssh.get_ssh_config_path()
+        config_path.write_text("Host other\n    HostName example.com\n")
+
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+
+        content = config_path.read_text()
+        assert "Host other" in content
+        assert "HostName example.com" in content
+        assert "Host github-work" in content
+
+    def test_add_twice_updates_in_place_without_duplicating(self, ssh):
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work_new")
+
+        content = ssh.get_ssh_config_path().read_text()
+        assert content.count("Host github-work") == 1
+        assert "/home/u/.ssh/id_work_new" in content
+        assert "/home/u/.ssh/id_work\n" not in content
+
+    def test_add_second_alias_keeps_first_intact(self, ssh):
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        ssh.add_host_alias("github-personal", "github.com", "/home/u/.ssh/id_personal")
+
+        content = ssh.get_ssh_config_path().read_text()
+        assert "Host github-work" in content
+        assert "Host github-personal" in content
+        assert "/home/u/.ssh/id_work" in content
+        assert "/home/u/.ssh/id_personal" in content
+
+    def test_has_host_alias(self, ssh):
+        assert ssh.has_host_alias("github-work") is False
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        assert ssh.has_host_alias("github-work") is True
+
+    def test_remove_returns_false_when_absent(self, ssh):
+        assert ssh.remove_host_alias("nonexistent") is False
+
+    def test_remove_deletes_only_its_own_block(self, ssh):
+        config_path = ssh.get_ssh_config_path()
+        config_path.write_text("Host other\n    HostName example.com\n")
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        ssh.add_host_alias("github-personal", "github.com", "/home/u/.ssh/id_personal")
+
+        assert ssh.remove_host_alias("github-work") is True
+
+        content = config_path.read_text()
+        assert "Host github-work" not in content
+        assert "Host github-personal" in content
+        assert "Host other" in content
+        assert "HostName example.com" in content
+
+    def test_remove_leaves_file_clean_when_last_alias(self, ssh):
+        config_path = ssh.get_ssh_config_path()
+        config_path.write_text("Host other\n    HostName example.com\n")
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+
+        assert ssh.remove_host_alias("github-work") is True
+
+        content = config_path.read_text()
+        assert "gitacc-switcher" not in content
+        assert "Host other" in content
+
+    def test_list_host_aliases_empty(self, ssh):
+        assert ssh.list_host_aliases() == {}
+
+    def test_list_host_aliases_returns_all(self, ssh):
+        ssh.add_host_alias("github-work", "github.com", "/home/u/.ssh/id_work")
+        ssh.add_host_alias(
+            "gitlab-personal",
+            "gitlab.com",
+            "/home/u/.ssh/id_personal",
+            ssh_user="deploy",
+        )
+
+        aliases = ssh.list_host_aliases()
+        assert aliases["github-work"] == {
+            "hostname": "github.com",
+            "user": "git",
+            "identity_file": "/home/u/.ssh/id_work",
+        }
+        assert aliases["gitlab-personal"] == {
+            "hostname": "gitlab.com",
+            "user": "deploy",
+            "identity_file": "/home/u/.ssh/id_personal",
+        }
+
+
 class TestGetKeyFingerprint:
     def test_returns_fingerprint(self, ssh, tmp_path):
         pub_key = tmp_path / "id_rsa_test.pub"