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

{gitacc_switcher-1.3.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.3.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
@@ -49,6 +49,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Opt-in SSH commit signing per account
 - 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
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -184,6 +185,40 @@ Kill the SSH agent and unset the global Git user config.
 gitacc logout
 ```
 
+### `gitacc rule add <account> [directory]` / `gitacc rule remove [directory]` / `gitacc rule list`
+
+Opt-in, direnv-style directory-based auto-switching: bind an account to a directory (and
+everything beneath it) so the right identity is picked automatically as you move around, instead
+of running `gitacc switch` by hand. `directory` defaults to the current directory. The most
+specific matching directory wins, so a rule on a subdirectory overrides one on its parent.
+
+```bash
+gitacc rule add work ~/projects/work      # anything under ~/projects/work uses "work"
+gitacc rule add personal ~/projects/side  # anything under ~/projects/side uses "personal"
+gitacc rule list
+gitacc rule remove ~/projects/side
+```
+
+Rules by themselves don't do anything — nothing triggers on `cd` until you install the shell hook
+below.
+
+### `gitacc rule hook <bash|zsh>`
+
+Print a shell snippet that calls `gitacc rule check` so rules apply automatically. Add it to your
+shell profile and restart your shell (or `source` it):
+
+```bash
+# bash
+gitacc rule hook bash >> ~/.bashrc
+
+# zsh
+gitacc rule hook zsh >> ~/.zshrc
+```
+
+The hook is silent unless it actually needs to switch accounts: no matching rule, an SSH agent
+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 autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -212,6 +247,7 @@ gitacc --version
 | Path | Purpose |
 |------|---------|
 | `~/.gitacc` | Stores all account entries (INI format) |
+| `~/.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 |
 
@@ -226,6 +262,13 @@ gitacc --version
     sign = false
 ```
 
+`~/.gitaccrules` format (one rule per line, most-specific directory wins):
+
+```
+/home/jane/projects/work = work
+/home/jane/projects/work/client-a = client-a
+```
+
 ## Requirements
 
 - Python 3.8+

{gitacc_switcher-1.3.0 → gitacc_switcher-1.5.0}/README.md

@@ -16,6 +16,7 @@ A Python CLI tool to easily switch between multiple Git SSH accounts. Manage mul
 - Opt-in SSH commit signing per account
 - 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
 - Shell autocomplete for bash and zsh
 - Cross-platform support (Linux / macOS)
 
@@ -151,6 +152,40 @@ Kill the SSH agent and unset the global Git user config.
 gitacc logout
 ```
 
+### `gitacc rule add <account> [directory]` / `gitacc rule remove [directory]` / `gitacc rule list`
+
+Opt-in, direnv-style directory-based auto-switching: bind an account to a directory (and
+everything beneath it) so the right identity is picked automatically as you move around, instead
+of running `gitacc switch` by hand. `directory` defaults to the current directory. The most
+specific matching directory wins, so a rule on a subdirectory overrides one on its parent.
+
+```bash
+gitacc rule add work ~/projects/work      # anything under ~/projects/work uses "work"
+gitacc rule add personal ~/projects/side  # anything under ~/projects/side uses "personal"
+gitacc rule list
+gitacc rule remove ~/projects/side
+```
+
+Rules by themselves don't do anything — nothing triggers on `cd` until you install the shell hook
+below.
+
+### `gitacc rule hook <bash|zsh>`
+
+Print a shell snippet that calls `gitacc rule check` so rules apply automatically. Add it to your
+shell profile and restart your shell (or `source` it):
+
+```bash
+# bash
+gitacc rule hook bash >> ~/.bashrc
+
+# zsh
+gitacc rule hook zsh >> ~/.zshrc
+```
+
+The hook is silent unless it actually needs to switch accounts: no matching rule, an SSH agent
+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 autocomplete install`
 
 Install tab-completion for your shell (bash or zsh). After running, restart your shell or `source` your profile.
@@ -179,6 +214,7 @@ gitacc --version
 | Path | Purpose |
 |------|---------|
 | `~/.gitacc` | Stores all account entries (INI format) |
+| `~/.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 |
 
@@ -193,6 +229,13 @@ gitacc --version
     sign = false
 ```
 
+`~/.gitaccrules` format (one rule per line, most-specific directory wins):
+
+```
+/home/jane/projects/work = work
+/home/jane/projects/work/client-a = client-a
+```
+
 ## Requirements
 
 - Python 3.8+

{gitacc_switcher-1.3.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.3.0"
+__version__ = "1.5.0"
 __author__ = "ktechhub"

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

@@ -7,6 +7,7 @@ from typing import Optional, Dict, List
 from .config_manager import ConfigManager
 from .ssh_manager import SSHManager
 from .hook_manager import HookManager
+from .rules_manager import RulesManager
 from .utils import echo_color, ask_yes_no, validate_ssh_key_type
 
 
@@ -17,6 +18,7 @@ class AccountManager:
         self.config_manager = ConfigManager()
         self.ssh_manager = SSHManager()
         self.hook_manager = HookManager()
+        self.rules_manager = RulesManager()
 
     def add_account(self, key_type: str = "rsa", sign: bool = False) -> bool:
         """Add a new Git account.
@@ -382,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.3.0 → gitacc_switcher-1.5.0}/gitacc_switcher/cli.py

@@ -2,6 +2,7 @@
 
 import argparse
 import sys
+from pathlib import Path
 from typing import Optional
 
 try:
@@ -12,6 +13,7 @@ except ImportError:
 from . import __version__
 from .account_manager import AccountManager
 from .completion import get_account_names
+from .shell_hook import get_hook_script, get_supported_shells
 from .utils import echo_color, get_ssh_key_types
 
 
@@ -46,10 +48,12 @@ 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)
 
         # Include account names in top-level completion so `gitacc <TAB>` works for
         # the `gitacc <account>` shorthand, not just for subcommand names.
@@ -76,9 +80,12 @@ 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)
         """
 
     def _add_add_command(self, subparsers: argparse._SubParsersAction) -> None:
@@ -170,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(
@@ -254,6 +272,80 @@ Examples:
         )
         install_parser.set_defaults(func=self._handle_autocomplete_install)
 
+    def _add_rule_command(self, subparsers: argparse._SubParsersAction) -> None:
+        """Add the 'rule' command parser for directory-based auto-switching."""
+        parser = subparsers.add_parser(
+            "rule",
+            help="Manage directory-based account auto-switch rules",
+            description="Add, remove, and list rules that auto-switch accounts by directory",
+        )
+        rule_subparsers = parser.add_subparsers(
+            dest="rule_command",
+            help="Rule commands",
+        )
+
+        add_parser = rule_subparsers.add_parser(
+            "add",
+            help="Add or update a directory rule",
+            description="Auto-switch to an account whenever inside the given "
+            "directory (or a subdirectory of it)",
+        )
+        account_arg = add_parser.add_argument(
+            "account_name",
+            help="Account to switch to",
+        )
+        add_parser.add_argument(
+            "directory",
+            nargs="?",
+            default=None,
+            help="Directory the rule applies to (default: current directory)",
+        )
+        if argcomplete:
+            account_arg.completer = lambda **kwargs: get_account_names()
+        add_parser.set_defaults(func=self._handle_rule_add)
+
+        remove_parser = rule_subparsers.add_parser(
+            "remove",
+            help="Remove a directory rule",
+        )
+        remove_parser.add_argument(
+            "directory",
+            nargs="?",
+            default=None,
+            help="Directory whose rule should be removed (default: current directory)",
+        )
+        remove_parser.set_defaults(func=self._handle_rule_remove)
+
+        list_parser = rule_subparsers.add_parser(
+            "list",
+            help="List all directory rules",
+        )
+        list_parser.set_defaults(func=self._handle_rule_list)
+
+        hook_parser = rule_subparsers.add_parser(
+            "hook",
+            help="Print a shell hook that auto-switches on directory change",
+            description="Print a snippet for your shell profile that calls "
+            "'gitacc rule check' so rules apply automatically as you move "
+            "between directories",
+        )
+        hook_parser.add_argument(
+            "shell",
+            choices=get_supported_shells(),
+            help="Shell to generate the hook for",
+        )
+        hook_parser.set_defaults(func=self._handle_rule_hook)
+
+        check_parser = rule_subparsers.add_parser(
+            "check",
+            help="Match the current directory against rules (used by the shell hook)",
+            description="Intended to be called by the shell hook on every "
+            "prompt render, not run directly; silently does nothing unless "
+            "the current directory matches a rule for a different account "
+            "than the one currently active",
+        )
+        check_parser.set_defaults(func=self._handle_rule_check)
+
     def _handle_autocomplete_install(self, args: argparse.Namespace) -> int:
         """Handle the 'autocomplete install' command."""
         if not argcomplete:
@@ -437,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)
@@ -457,6 +583,80 @@ Examples:
         )
         return 0 if success else 1
 
+    def _handle_rule_add(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule add' command."""
+        if not self.account_manager.account_exists(args.account_name):
+            echo_color("r", f'Account "{args.account_name}" not found!')
+            return 1
+
+        directory = Path(args.directory) if args.directory else Path.cwd()
+        success = self.account_manager.rules_manager.add_rule(
+            directory, args.account_name
+        )
+        if success:
+            resolved = Path(directory).expanduser().resolve()
+            echo_color("g", f'Rule added: "{resolved}" → "{args.account_name}"')
+        else:
+            echo_color("r", "Failed to add rule!")
+        return 0 if success else 1
+
+    def _handle_rule_remove(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule remove' command."""
+        directory = Path(args.directory) if args.directory else Path.cwd()
+        success = self.account_manager.rules_manager.remove_rule(directory)
+        resolved = Path(directory).expanduser().resolve()
+        if success:
+            echo_color("g", f'Rule removed for "{resolved}"')
+        else:
+            echo_color("y", f'No rule was set for "{resolved}"')
+        return 0 if success else 1
+
+    def _handle_rule_list(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule list' command."""
+        rules = self.account_manager.rules_manager.list_rules()
+        if not rules:
+            echo_color("y", "No directory rules registered yet.")
+            return 0
+
+        echo_color("g", "Directory auto-switch rules:")
+        for directory, account_name in rules.items():
+            print(f"  {directory} → {account_name}")
+        return 0
+
+    def _handle_rule_hook(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule hook' command."""
+        script = get_hook_script(args.shell)
+        if not script:
+            echo_color("r", f'Unsupported shell: "{args.shell}"')
+            return 1
+        print(script)
+        return 0
+
+    def _handle_rule_check(self, args: argparse.Namespace) -> int:
+        """Handle the 'rule check' command.
+
+        Called by the installed shell hook on every prompt render, so it
+        must stay quiet unless there is actually something to do: no match,
+        an already-correct identity, and a down SSH agent (which
+        `switch_account` would otherwise report loudly on every prompt) are
+        all silent no-ops.
+        """
+        account_name = self.account_manager.rules_manager.find_matching_account(
+            Path.cwd()
+        )
+        if not account_name or not self.account_manager.account_exists(account_name):
+            return 0
+
+        status = self.account_manager.get_status()
+        if status.get("matched_account") == account_name:
+            return 0
+
+        if not self.account_manager.ssh_manager.is_ssh_agent_running():
+            return 0
+
+        success = self.account_manager.switch_account(account_name)
+        return 0 if success else 1
+
     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.5.0/gitacc_switcher/rules_manager.py

@@ -0,0 +1,118 @@
+"""Directory-based auto-switch rule storage and lookup.
+
+Rules map a directory (and everything beneath it) to the account that should
+become active whenever the shell's current working directory is there. This
+is the pure-Python half of the opt-in auto-switch feature; the actual
+"notice I changed directories" trigger comes from a shell hook (see
+`shell_hook.py`) that calls `gitacc rule check` on every prompt render.
+"""
+
+import re
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class RulesManager:
+    """Manages directory-to-account auto-switch rules."""
+
+    def __init__(self, rules_file: Optional[Path] = None):
+        self.rules_file = rules_file or (Path.home() / ".gitaccrules")
+
+    def _normalize_path(self, directory: Path) -> str:
+        """Resolve a directory to its canonical absolute form."""
+        return str(Path(directory).expanduser().resolve())
+
+    def list_rules(self) -> Dict[str, str]:
+        """Read all rules from the rules file.
+
+        Returns:
+            Dictionary mapping normalized directory path to account name, in
+            file order. Blank lines and lines starting with '#' are ignored.
+        """
+        rules: Dict[str, str] = {}
+        if not self.rules_file.exists():
+            return rules
+
+        with open(self.rules_file, "r") as f:
+            for raw_line in f:
+                line = raw_line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                match = re.match(r"^(.+?)\s*=\s*(.+)$", line)
+                if not match:
+                    continue
+                directory = match.group(1).strip()
+                account_name = match.group(2).strip()
+                if directory and account_name:
+                    rules[directory] = account_name
+
+        return rules
+
+    def _write_rules(self, rules: Dict[str, str]) -> None:
+        with open(self.rules_file, "w") as f:
+            for directory, account_name in rules.items():
+                f.write(f"{directory} = {account_name}\n")
+
+    def add_rule(self, directory: Path, account_name: str) -> bool:
+        """Add or update the rule for a directory.
+
+        Args:
+            directory: Directory the rule applies to (and its subdirectories)
+            account_name: Account to switch to while inside that directory
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            normalized = self._normalize_path(directory)
+            rules = self.list_rules()
+            rules[normalized] = account_name
+            self._write_rules(rules)
+            return True
+        except OSError:
+            return False
+
+    def remove_rule(self, directory: Path) -> bool:
+        """Remove the rule for a directory, if one exists.
+
+        Args:
+            directory: Directory whose rule should be removed
+
+        Returns:
+            True if a rule was removed, False if none existed or on error
+        """
+        try:
+            normalized = self._normalize_path(directory)
+            rules = self.list_rules()
+            if normalized not in rules:
+                return False
+            del rules[normalized]
+            self._write_rules(rules)
+            return True
+        except OSError:
+            return False
+
+    def find_matching_account(self, cwd: Path) -> Optional[str]:
+        """Find the account whose rule most specifically matches a directory.
+
+        Walks from the given directory up through its parents, direnv-style,
+        and returns the account for the first (deepest, most specific) rule
+        directory that is the given directory or an ancestor of it.
+
+        Args:
+            cwd: Directory to match against registered rules
+
+        Returns:
+            Matching account name, or None if no rule applies
+        """
+        rules = self.list_rules()
+        if not rules:
+            return None
+
+        current = Path(cwd).expanduser().resolve()
+        for directory in [current, *current.parents]:
+            account_name = rules.get(str(directory))
+            if account_name:
+                return account_name
+
+        return None

gitacc_switcher-1.5.0/gitacc_switcher/shell_hook.py

@@ -0,0 +1,51 @@
+"""Shell hook snippets for directory-based auto-switching.
+
+These are opt-in: nothing in gitacc installs them automatically. A user adds
+the output of `gitacc rule hook <shell>` to their shell profile, which then
+calls `gitacc rule check` whenever the prompt is rendered (bash) or the
+working directory changes (zsh), so the active account follows whatever
+rules were registered with `gitacc rule add`.
+"""
+
+from typing import Optional
+
+_BASH_HOOK = """\
+_gitacc_hook() {
+  local previous_exit_status=$?
+  command gitacc rule check
+  return $previous_exit_status
+}
+if [[ ";${PROMPT_COMMAND:-};" != *";_gitacc_hook;"* ]]; then
+  PROMPT_COMMAND="_gitacc_hook${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+fi"""
+
+_ZSH_HOOK = """\
+_gitacc_hook() {
+  command gitacc rule check
+}
+if [[ -z "${chpwd_functions[(r)_gitacc_hook]}" ]]; then
+  chpwd_functions+=(_gitacc_hook)
+fi
+_gitacc_hook"""
+
+_HOOKS = {
+    "bash": _BASH_HOOK,
+    "zsh": _ZSH_HOOK,
+}
+
+
+def get_hook_script(shell: str) -> Optional[str]:
+    """Get the shell hook snippet for a given shell.
+
+    Args:
+        shell: Shell name ("bash" or "zsh")
+
+    Returns:
+        Hook script text, or None if the shell isn't supported
+    """
+    return _HOOKS.get(shell.lower())
+
+
+def get_supported_shells() -> list:
+    """Get the list of shells a hook script can be generated for."""
+    return list(_HOOKS.keys())

{gitacc_switcher-1.3.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.