artemis_framework 0.2.3__tar.gz → 0.3.1__tar.gz

{artemis_framework-0.2.3 → artemis_framework-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: artemis_framework
-Version: 0.2.3
+Version: 0.3.1
 Summary: A package for doing great things!
 License: MIT
 License-File: LICENSE

artemis_framework-0.3.1/artemis_framework/asphodel/tui/app.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.screen import Screen
+from textual.widgets import Footer, Header, Label
+
+try:
+    from artemis_framework.asphodel.core import build_gpg
+except ImportError as exc:
+    print(
+        f"[FATAL] Cannot import '.asphodel.core': {exc}\n"
+        "Ensure the artemis_framework.asphodel package is installed and available on your PATH."
+    )
+    sys.exit(1)
+
+from artemis_framework.asphodel.tui.settings import AppSettings, load_settings
+
+
+def _import_key_management_screen():
+    from artemis_framework.asphodel.tui.screens.key_management import KeyManagementScreen
+    return KeyManagementScreen
+
+
+def _import_encrypt_decrypt_screen():
+    from artemis_framework.asphodel.tui.screens.encrypt_decrypt import EncryptDecryptScreen
+    return EncryptDecryptScreen
+
+
+def _import_config_screen():
+    from artemis_framework.asphodel.tui.screens.app_config import AppConfigScreen
+    return AppConfigScreen
+
+
+class PlaceholderScreen(Screen):
+
+    BINDINGS = [Binding("escape,q", "app.pop_screen", "Back", priority=True)]
+
+    def __init__(self, title: str = "Coming soon", **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._title = title
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Label(
+            f"\n  [ {self._title} ]\n\n  This screen is not yet implemented.\n  Press [b]Q[/b] or [b]Escape[/b] to [i][u]go back[/u][/i].",
+            markup=True,
+            id="placeholder=label"
+        )
+        yield Footer()
+
+
+class AsphodelApp(App):
+    TITLE = "Asphodel PGP Terminal Interface"
+    SUB_TITLE = "GnuPG key management & crypto operations"
+
+    CSS = """
+    Screen {
+        background: $background;
+    }
+    Header {
+        background: $primary;
+        color: $text;
+        height: 1;
+        dock: top;
+    }
+    Footer {
+        background: $primary-darken-2;
+        color: $text-muted;
+        height: 1;
+        dock: bottom;
+    }
+    #welcome-label {
+        padding: 1 4;
+        color: $text;
+        content-align: left top;
+    }
+    #placeholder-label {
+        padding: 2 4;
+        color: $text-muted;
+        content-align: left top;
+    }
+    """
+
+    BINDINGS = [
+        Binding("k", "switch_screen('keys')", "Keys"),
+        Binding("e", "switch_screen('encrypt')", "Encrypt/Decrypt"),
+        Binding("c", "switch_screen('config')", "Configuration", priority=True),
+        Binding("escape,q", "quit", "Quit"),
+    ]
+
+    def __init__(self, gpg_instance, settings: AppSettings, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.gpg = gpg_instance
+        self.settings = settings
+        self._passphrase_cache: dict[str, str] = {}
+
+    def cache_passphrase(self, fingerprint: str, passphrase: str | None) -> None:
+        if not self.settings.passphrase_cache_enabled:
+            return
+        if passphrase:
+            self._passphrase_cache[fingerprint] = passphrase
+
+    def get_cached_passphrase(self, fingerprint: str) -> str | None:
+        if not self.settings.passphrase_cache_enabled:
+            return
+        return self._passphrase_cache.get(fingerprint)
+
+    def evict_passphrase(self, fingerprint: str) -> None:
+        self._passphrase_cache.pop(fingerprint, None)
+
+    def clear_passphrase_cache(self) -> None:
+        self._passphrase_cache.clear()
+
+    @property
+    def passphrase_cache_size(self) -> int:
+        return len(self._passphrase_cache)
+
+    def on_mount(self) -> None:
+        self.install_screen(self._make_key_screen, name="keys")
+        self.install_screen(self._make_encrypt_screen, name="encrypt")
+        self.install_screen(self._make_config_screen, name="config")
+
+    def _make_key_screen(self):
+        try:
+            KeyManagementScreen = _import_key_management_screen()
+            return KeyManagementScreen(self.gpg)
+        except (ImportError, ModuleNotFoundError):
+            return PlaceholderScreen("Key Management  (not yet implemented)")
+
+    def _make_encrypt_screen(self):
+        try:
+            EncryptDecryptScreen = _import_encrypt_decrypt_screen()
+            return EncryptDecryptScreen(self.gpg)
+        except (ImportError, ModuleNotFoundError):
+            return PlaceholderScreen("Encrypt / Decrypt   (not yet implemented)")
+
+    def _make_config_screen(self):
+        try:
+            AppConfigScreen = _import_config_screen()
+            return AppConfigScreen(self.settings)
+        except (ImportError, ModuleNotFoundError):
+            return PlaceholderScreen("App Configuration  (not yet implemented)")
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Label(_WELCOME_TEXT, id="welcome-label", markup=True)
+        yield Footer()
+
+    _TOP_LEVEL_SCREENS = frozenset({
+        "KeyManagementScreen",
+        "EncryptDecryptScreen",
+        "AppConfigScreen",
+    })
+
+    def action_switch_screen(self, screen_name: str) -> None:
+        if self.screen.__class__.__name__ in self._TOP_LEVEL_SCREENS:
+            return
+        self.push_screen(screen_name)
+
+    def on_config_screen_saved(
+        self,
+        message: "AppConfigScreen.Saved"    # type: ignore[name-defined]
+    ) -> None:
+        new_cfg = message.settings
+        cache_was_on = self.settings.passphrase_cache_enabled
+        self.settings = new_cfg
+
+        if cache_was_on and not new_cfg.passphrase_cache_enabled:
+            self.clear_passphrase_cache()
+            self.notify(
+                "Passphrase cache cleared.",
+                title="Cache disabled",
+                severity="information",
+                timeout=3
+            )
+
+        try:
+            new_gpg = new_cfg.build_gpg()
+        except RuntimeError as exc:
+            self.notify(
+                f"Settings saved, but GPG could not be reloaded:\n{exc}\n\n"
+                "The previuos keyring is still active.",
+                title="GPG reload failed",
+                severity="warning",
+                timeout=10
+            )
+            return
+
+        self.gpg = new_gpg
+        self.SUB_TITLE = f"keyring:  {new_gpg.gnupghome}"
+
+        self._propagate_gpg_to_screens(new_gpg)
+
+        self.notify(
+            f"Keyring:  {new_gpg.gnupghome}",
+            title="Settings saved",
+            severity="information",
+            timeout=4
+        )
+
+    def _propagate_gpg_to_screens(self, gpg) -> None:
+        for name in ("keys", "encrypt"):
+            try:
+                screen = self._installed_screens.get(name)
+                if screen is None or callable(screen):
+                    continue
+
+                if hasattr(screen, "gpg"):
+                    screen.gpg = gpg
+
+                try:
+                    from artemis_framework.asphodel.tui.widgets.key_list import KeyListWidget
+                    for widget in screen.query(KeyListWidget):
+                        widget.refresh_keys(gpg)
+                except Exception:
+                    pass
+            except Exception:
+                pass
+
+
+
+WELCOME_TEXT = """\
+
+  ██████╗ ██████╗  ██████╗
+ ██╔════╝ ██╔══██╗██╔════╝
+ ██║  ███╗██████╔╝██║  ███╗
+ ██║   ██║██╔═══╝ ██║   ██║
+ ╚██████╔╝██║     ╚██████╔╝
+  ╚═════╝ ╚═╝      ╚═════╝   TUI
+
+[i]GnuPG key management & cryptographic operations.[/i]
+
+[b][u]Navigation[/u][/b]
+
+[b]K[/b]    →   Key Management    [i](generate, import, export, delete keys)[/i]
+[b]E[/b]    →   Encrypt / Decrypt [i](encrypt, decrypt, sign, verify)[/i]
+[b]S[/b]    →   Settings          [i](keyring path, GPG binary, key defaults)[/i]
+[b]Esc[/b]    →   Quit
+
+The keyring path is shown in the header subtitle.
+[i]Use [b]`--gnupghome`[/b] on the command line to point at a different keyring.[/i]
+"""
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="GnuPG key management & crypto operations",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    parser.add_argument(
+        "--gnupghome",
+        type=Path,
+        default=None,
+        metavar="PATH",
+        help=(
+            "Path to the GNUPGHOME keyring directory. "
+            "Overrides the stored setting for this session. "
+            "Defaults to the value saved in settings, or the built-in test keyring."
+        )
+    )
+    parser.add_argument(
+        "--gpg-binary",
+        type=str,
+        default=None,
+        metavar="BINARY",
+        help=(
+            "Name or full path of the GPG binary. "
+            "Overrides the stored setting for this session."
+        )
+    )
+    return parser.parse_args()
+
+
+def asphodel_launch() -> None:
+    args = parse_args()
+
+    cfg = load_settings()
+
+    if args.gnupghome is not None:
+        cfg.gnupghom = str(args.gnupghome)
+    if args.gpg_binary is not None:
+        cfg.gpg_binary = str(args.gpg_binary)
+
+    try:
+        gpg = cfg.build_gpg()
+    except RuntimeError as exc:
+        print(f"[FATAL] Failed to initialize GPG: {exc}")
+        sys.exit(1)
+
+    app = AsphodelApp(gpg_instance=gpg, settings=cfg)
+    app.SUB_TITLE = f"keyring:  {gpg.gnupghome}"
+
+    app.run()
+
+
+if __name__ == "__main__":
+    asphodel_launch()

artemis_framework-0.3.1/artemis_framework/asphodel/tui/settings.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+
+def _config_dir() -> Path:
+    if os.name == "nt":
+        base = Path(os.environ.get("APPDATA", Path.home()))
+    else:
+        base = Path(os.environ.get("XDG_CONFIG_HOME", Path.hom() / ".config"))
+    return base / "artemis-framework" / "asphodel"
+
+
+CONFIG_FILE = _config_dir() / "settings.json"
+
+
+_DEFAULT_GNUPGHOME: str = ""
+_DEFAULT_GPG_BINARY: str = "gpg"
+_DEFAULT_ALGORITHM: str = "rsa"
+_DEFAULT_EXPIRE: str = "2y"
+_DEFAULT_KEYSERVER_URL: str = "https://keys.openpgp.org"
+_DEFAULT_PASSPHRASE_CACHE: bool = False
+
+
+@dataclass
+class AppSettings:
+    gnupghome: str = field(default=_DEFAULT_GNUPGHOME)
+    gpg_binary: str = field(default=_DEFAULT_GPG_BINARY)
+    algorithm: str = field(default=_DEFAULT_ALGORITHM)
+    expire: str = field(default=_DEFAULT_EXPIRE)
+    keyserver_url: str = field(default=_DEFAULT_KEYSERVER_URL)
+    passphrase_cache_enabled: bool = field(default=_DEFAULT_PASSPHRASE_CACHE)
+
+    def gnupghome_path(self) -> Path | None:
+        if not self.gnupghome.strip():
+            return None
+        return Path(self.gnupghome).expanduser().resolve()
+
+    def gpg_binary_resolved(self) -> str:
+        return self.gpg_binary.strip() or _DEFAULT_GPG_BINARY
+
+    def keyserver_url_resolved(self) -> str:
+        url = self.keyserver_url.strip()
+        return url if url else _DEFAULT_KEYSERVER_URL
+
+    def build_gpg(self):
+        from artemis_framework.asphodel.core import build_gpg as _build_gpg
+        return _build_gpg(
+            gnupghome=self.gnupghome_path(),
+            binary=self.gpg_binary_resolved()
+        )
+
+    def validate_gnupghome(self) -> tuple[bool, str]:
+        if not self.gnupghome.strip():
+            return True, "Use asphodel-pgp default (test keyring)"
+        p = Path(self.gnupghome).expanduser()
+        if p.exists():
+            if p.is_dir():
+                return True, str(p.resolve())
+            return False, f"Path exists but is not a directory: {p}"
+        return True, f"Will be created: {p.resolve()}"
+
+    def validate_gpg_binary(self) -> tuple[bool, str]:
+        import shutil
+        binary = self.gpg_binary_resolved()
+        found = shutil.which(binary)
+        if found:
+            return True, found
+        p = Path(binary)
+        if p.exists() and os.access(p, os.X_OK):
+            return True, str(p.resolve())
+
+        return False, f"'{binary}' not found on PATH"
+
+    def validate_keyserver_url(self) -> tuple[bool, str]:
+        url = self.keyserver_url_resolved()
+        if url.startswith("https://") or url.startswith("http://"):
+            return True, url
+        return False, f"URL must start with https:// -or- http://   (got: '{url}')"
+
+
+def load_settings() -> AppSettings:
+    if not CONFIG_FILE.exists():
+        return AppSettings()
+
+    try:
+        raw = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return AppSettings()
+
+    return AppSettings(
+        gnupghome=raw.get("gnupghome", _DEFAULT_GNUPGHOME),
+        gpg_binary=raw.get("gpg_binary", _DEFAULT_GPG_BINARY),
+        algorithm=raw.get("algorithm", _DEFAULT_ALGORITHM),
+        expire=raw.get("expire", _DEFAULT_EXPIRE),
+        keyserver_url=raw.get("keyserver_url", _DEFAULT_KEYSERVER_URL),
+        passphrase_cache_enabled=bool(
+            raw.get("passphrase_cache_enabled", _DEFAULT_PASSPHRASE_CACHE)
+        )
+    )
+
+
+def save_settings(cfg: AppSettings) -> bool:
+    try:
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.dumps(asdict(cfg), indent=2, ensure_ascii=False)
+
+        fd, tmp_path = tempfile.mkstemp(
+            dir=CONFIG_FILE.parent,
+            prefix=".settings_tmp_",
+            suffix=".json"
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as file:
+                file.write(payload)
+            Path(tmp_path).replace(CONFIG_FILE)
+        except Exception:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
+        return True
+    except OSError:
+        return False

{artemis_framework-0.2.3 → artemis_framework-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "artemis_framework"
-version = "0.2.3"
+version = "0.3.1"
 description = "A package for doing great things!"
 authors = ["Dylan Garrett"]
 license = "MIT"