passtui 0.0.1__py3-none-any.whl

passtui/__main__.py

@@ -0,0 +1,8 @@
+import click
+from passtui.app import PassTUI
+
+
+@click.command()
+def cli():
+    app = PassTUI()
+    app.run()

passtui/app.py

@@ -0,0 +1,147 @@
+from functools import Placeholder
+from textual.app import App
+from textual import on, work
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.widgets import Footer, Input, Tree
+from textual.widgets.tree import TreeNode
+from passtui.security import passcli
+from passtui.widgets.search import Search
+from passtui.widgets.pass_list import PassList
+from passtui.widgets.pass_data import PassData
+from passtui.screens.input_modal import InputModalScreen
+from passtui.screens.gpg_keygen_modal import GpgKeygenModalScreen
+from passtui.screens.gpg_export_modal import GpgExportModalScreen
+
+
+class PassTUI(App):
+    keys = passcli.list_keys()
+
+    CSS_PATH = "app.tcss"
+
+    BINDINGS = [
+        Binding("/", "search_password", "Search password"),
+        Binding("n", "add_new_password", "Add new password"),
+        Binding("e", "focus_editor", "Focus editor"),
+        Binding("t", "focus_explorer", "Focus explorer"),
+        Binding("s", "sync", "Sync"),
+        Binding("g", "create_gpg_store", "Create new GPG Store"),
+        Binding("x", "export_gpg", "Export GPG key"),
+        Binding("z", "import_gpg", "Import GPG key"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield Search(data=self.keys, id="search")
+        yield PassList(items=self.keys)
+        yield PassData()
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.theme = "rose-pine-moon"
+
+    def action_search_password(self) -> None:
+        self.query_one(Search).set_focus()
+
+    def action_focus_editor(self) -> None:
+        self.query_one(PassData).set_focus()
+
+    def action_focus_explorer(self) -> None:
+        self.screen.focus_next(PassList)
+
+    @on(Input.Changed, "#search")
+    async def on_search_changed(self, event: Input.Changed) -> None:
+        pass_list = self.query_one(Search).results
+        widget: PassList = self.query_one(PassList)
+        widget.is_filter = True if event.value else False
+        widget.items = pass_list
+
+    @on(Tree.NodeSelected)
+    async def handle_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        self.update_selected(event.node)
+
+    @work
+    async def update_selected(self, node: TreeNode) -> None:
+        if node.data:
+            pass_model = passcli.get_store_key(node.data)
+            if not pass_model:
+                return
+            self.query_one(PassData).set_password(
+                pass_model=pass_model, pass_path=node.data
+            )
+
+    def action_add_new_password(self) -> None:
+        self.query_one(PassData).add_new_password()
+
+    @work
+    async def action_sync(self) -> None:
+        if passcli.is_git_initialized():
+            try:
+                passcli.sync_git()
+                self.notify("Git sync completed")
+            except Exception as e:
+                self.notify(f"Failed to sync git: {e}", severity="error")
+        else:
+            repo_url = await self.push_screen_wait(
+                InputModalScreen(
+                    label="Enter git repository URL",
+                    placeholder="(e.g., git@github.com:user/repo.git)",
+                )
+            )
+            if repo_url:
+                try:
+                    passcli.init_git(repo_url)
+                    self.notify("Git initialized and pushed")
+                except Exception as e:
+                    self.notify(f"Failed to init git: {e}", severity="error")
+
+    @work
+    async def action_create_gpg_store(self) -> None:
+        key_data = await self.push_screen_wait(GpgKeygenModalScreen())
+        if key_data:
+            try:
+                fingerprint = passcli.create_gpg_store(
+                    key_data.name, key_data.email, key_data.path
+                )
+                if not fingerprint:
+                    self.notify("Failed to create GPG Store", severity="error")
+                    return
+
+                self.notify(f"GPG Store created: {fingerprint}")
+            except Exception as e:
+                self.notify(f"Error: {e}", severity="error")
+
+    @work
+    async def action_export_gpg(self) -> None:
+        export_data = await self.push_screen_wait(GpgExportModalScreen())
+        if export_data:
+            try:
+                output_path = passcli.export_gpg_key(
+                    passphrase=export_data.passphrase,
+                    output_path=export_data.output_path,
+                )
+                if not output_path:
+                    self.notify("Failed to export GPG key", severity="error")
+                    return
+
+                self.notify(f"GPG key exported to {output_path}")
+            except Exception as e:
+                self.notify(f"Error: {e}", severity="error")
+
+    @work
+    async def action_import_gpg(self) -> None:
+        filepath = await self.push_screen_wait(
+            InputModalScreen(
+                label="Enter path to GPG key file",
+                placeholder="(e.g., ~/passtui/gpg-export.asc)",
+            )
+        )
+        if filepath:
+            try:
+                success = passcli.import_gpg_key(filepath)
+                if not success:
+                    self.notify("Failed to import GPG key", severity="error")
+                    return
+
+                self.notify("GPG key imported successfully")
+            except Exception as e:
+                self.notify(f"Error: {e}", severity="error")

passtui/app.tcss

@@ -0,0 +1,10 @@
+* {
+  scrollbar-size-vertical: 1;
+}
+
+PassTUI Screen {
+  layout: grid;
+  grid-size: 2;
+  grid-columns: 1fr 2fr;
+  grid-rows: 1fr 5fr;
+}

passtui/models/pass_store.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, fields
+
+
+@dataclass(init=False)
+class PassModel:
+    """
+    This model follows the passwordstore.org data organization.
+
+    The copy features in `pass` and `passpy` copy only the first line of an
+    entry. Following the recommended pattern:
+
+        "This is the preferred organizational scheme used by the author. The
+        --clip / -c options will only copy the first line of such a file to the
+        clipboard, thereby making it easy to fetch the password for login forms,
+        while retaining additional information in the same file."
+
+    Reference: https://www.passwordstore.org/
+    """
+
+    password: str
+    username: str
+    url: str
+    meta: list[str]
+
+    _raw_data: str
+    _template_ignored: tuple[str, ...] = (
+        "_template_ignored",
+        "password",
+        "_raw_data",
+        "meta",
+    )
+
+    def __init__(self, data: str | None) -> None:
+        if data is None:
+            lines = []
+        else:
+            lines = data.strip().split("\n")
+
+        password = lines[0] if lines else ""
+        username = ""
+        url = ""
+        meta = []
+
+        for line in lines[1:]:
+            if line.startswith("Username:"):
+                username = line.split(":", 1)[1].strip()
+            elif line.startswith("URL:"):
+                url = line.split(":", 1)[1].strip()
+            else:
+                meta.append(line.strip())
+
+        self.password = password
+        self.username = username
+        self.url = url
+        self.meta = meta
+        self._raw_data = data if data is not None else ""
+
+    def __str__(self) -> str:
+        return self._raw_data
+
+    @classmethod
+    def get_new_entry_template(cls) -> tuple[PassModel, str]:
+        lines = ["(add your password here)"]
+        for field in fields(cls):
+            if field.name not in cls._template_ignored:
+                lines.append(f"{field.name.capitalize()}: ")
+        template = "\n".join(lines)
+        return cls(template), template

passtui/screens/gpg_export_modal.py

@@ -0,0 +1,95 @@
+from typing import NamedTuple
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Grid, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, Button
+
+
+class GpgExportData(NamedTuple):
+    passphrase: str
+    output_path: str | None
+
+
+class GpgExportModalScreen(ModalScreen[GpgExportData | None]):
+    """
+    This only works for GPG keys that were created with passtui,
+    where we use only one GPG key per store.
+    """
+
+    BINDINGS = [
+        Binding("enter", "submit", "Submit", priority=True),
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    DEFAULT_CSS = """
+    GpgExportModalScreen {
+        align: center middle;
+    }
+    GpgExportModalScreen Grid {
+        column-span: 2;
+        grid-size: 2;
+        grid-gutter: 0 2;
+        padding: 0 2;
+        width: 80;
+        height: 11;
+        border: thick $background 80%;
+        background: $surface;
+    }
+    GpgExportModalScreen Horizontal {
+        column-span: 2;
+        border: solid $primary-muted;
+    }
+    GpgExportModalScreen Horizontal Label {
+        margin: 0 1 0 0;
+    }
+    GpgExportModalScreen Button {
+        width: 1fr;
+        height: 1fr;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Grid():
+            with Horizontal():
+                yield Label("Enter GPG key passphrase:")
+                yield Input(
+                    placeholder="(e.g., password)",
+                    id="passphrase",
+                    password=True,
+                    compact=True,
+                )
+            with Horizontal():
+                yield Label("Output file path (optional):")
+                yield Input(
+                    placeholder="(defaults: ~/passtui/gpg-export.asc)",
+                    id="output",
+                    compact=True,
+                )
+            yield Button("(Enter) Submit", variant="primary", id="submit")
+            yield Button("(Esc) Cancel", variant="error", id="cancel")
+
+    @on(Button.Pressed, "#submit")
+    async def handle_button_submit(self) -> None:
+        self.action_submit()
+
+    @on(Button.Pressed, "#cancel")
+    async def handle_button_cancel(self) -> None:
+        self.action_cancel()
+
+    def action_submit(self) -> None:
+        passphrase = self.query_one("#passphrase", Input).value
+        output = self.query_one("#output", Input).value
+        if passphrase:
+            self.dismiss(
+                GpgExportData(
+                    passphrase=passphrase, output_path=output if output else None
+                )
+            )
+        else:
+            self.notify("Passphrase is required", severity="error")
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

passtui/screens/gpg_keygen_modal.py

@@ -0,0 +1,96 @@
+from typing import NamedTuple
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Grid, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, Button
+
+
+class GpgKeyData(NamedTuple):
+    name: str
+    email: str
+    path: str | None
+
+
+class GpgKeygenModalScreen(ModalScreen[GpgKeyData | None]):
+    BINDINGS = [
+        Binding("enter", "submit", "Submit", priority=True),
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    DEFAULT_CSS = """
+    GpgKeygenModalScreen {
+        align: center middle;
+    }
+    GpgKeygenModalScreen Grid {
+        column-span: 2;
+        grid-size: 2;
+        grid-gutter: 0 2;
+        padding: 0 2;
+        width: 80;
+        height: 14;
+        border: thick $background 80%;
+        background: $surface;
+    }
+    GpgKeygenModalScreen Horizontal {
+        column-span: 2;
+        border: solid $primary-muted;
+    }
+    GpgKeygenModalScreen Horizontal Label {
+        margin: 0 1 0 0;
+    }
+    GpgKeygenModalScreen Button {
+        width: 1fr;
+        height: 1fr;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Grid():
+            with Horizontal():
+                yield Label("Enter your name:")
+                yield Input(
+                    placeholder="(e.g., name)",
+                    id="name",
+                    compact=True,
+                )
+            with Horizontal():
+                yield Label("Enter your email:")
+                yield Input(
+                    placeholder="(e.g., name@email.com)",
+                    id="email",
+                    compact=True,
+                )
+            with Horizontal():
+                yield Label("Password Store path (optional):")
+                yield Input(
+                    placeholder="(e.g., my-passwords/emails/gmail) ",
+                    id="path",
+                    compact=True,
+                )
+            yield Button("(Enter) Submit", variant="primary", id="submit")
+            yield Button("(Esc) Cancel", variant="error", id="cancel")
+
+    @on(Button.Pressed, "#submit")
+    async def handle_button_submit(self) -> None:
+        self.action_submit()
+
+    @on(Button.Pressed, "#cancel")
+    async def handle_button_cancel(self) -> None:
+        self.action_cancel()
+
+    def action_submit(self) -> None:
+        name = self.query_one("#name", Input).value
+        email = self.query_one("#email", Input).value
+        path = self.query_one("#path", Input).value
+        if name and email:
+            self.dismiss(
+                GpgKeyData(name=name, email=email, path=path if path else None)
+            )
+        else:
+            self.notify("Name and email are required", severity="error")
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

passtui/screens/input_modal.py

@@ -0,0 +1,79 @@
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Grid, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Input, Label, Button
+from typing import Any
+
+
+class InputModalScreen(ModalScreen[str | None]):
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    DEFAULT_CSS = """
+    InputModalScreen {
+        align: center middle;
+    }
+    InputModalScreen Grid {
+        column-span: 2;
+        grid-size: 2;
+        grid-gutter: 1 2;
+        grid-rows: 1fr 3;
+        padding: 0 2;
+        width: 80;
+        height: 9;
+        border: thick $background 80%;
+        background: $surface;
+    }
+    InputModalScreen Horizontal {
+        column-span: 2;
+        border: solid $primary-muted;
+    }
+    InputModalScreen Horizontal Label {
+        margin: 0 1 0 0;
+    }
+    InputModalScreen Button {
+        width: 1fr;
+        height: 1fr;
+    }
+    """
+
+    def __init__(
+        self,
+        label: str = "Input",
+        placeholder: str = "Enter value",
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self._label = label
+        self._placeholder = placeholder
+
+    def compose(self) -> ComposeResult:
+        with Grid():
+            with Horizontal():
+                yield Label(self._label + ":")
+                yield Input(placeholder=self._placeholder, compact=True)
+            yield Button("(Enter) Submit", variant="primary", id="submit")
+            yield Button("(Esc) Cancel", variant="error", id="cancel")
+
+    @on(Button.Pressed, "#submit")
+    async def handle_button_submit(self) -> None:
+        value = self.query_one(Input).value
+        self.submit(value)
+
+    @on(Button.Pressed, "#cancel")
+    async def handle_button_cancel(self) -> None:
+        self.action_cancel()
+
+    @on(Input.Submitted)
+    async def on_submit(self, event: Input.Submitted) -> None:
+        self.submit(event.value)
+
+    def submit(self, value: str | None) -> None:
+        self.dismiss(value if value else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)

passtui/security.py

@@ -0,0 +1,170 @@
+import os
+import subprocess
+import secrets
+
+import passpy
+
+from passpy.gpg import GPG, _get_gpg_recipients, reencrypt_path
+from passpy.git import git_add_path
+from pathlib import Path
+from passtui.models.pass_store import PassModel
+
+
+class PassCLI:
+    def __init__(self):
+        self._store = passpy.Store()
+        self._gpg = GPG(gpgbinary=self._store.gpg_bin, options=self._store.gpg_opts)
+
+    def get_store_key(self, key: str) -> PassModel | None:
+        key_data = self._store.get_key(key)
+        return PassModel(key_data) if key_data else None
+
+    def save_store_key(self, path: str, pass_model: PassModel) -> None:
+        self._store.set_key(path, str(pass_model), force=True)
+
+    def list_keys(self) -> list[str]:
+        if not self._store.is_init():
+            return []
+        return list(self._store)
+
+    def is_git_initialized(self) -> bool:
+        return self._store.repo is not None
+
+    def init_git(self, repo_url: str) -> None:
+        """
+        This method is intended for new stores only.
+        Stores that were previously created in the repository will cause an error and will not sync.
+        """
+        if self.is_git_initialized():
+            return
+
+        self._store.init_git()
+        self._store.git("remote", "add", "origin", repo_url)
+        self._store.git("push", "origin", "master")
+
+    def sync_git(self) -> None:
+        if not self.is_git_initialized():
+            return
+
+        self._store.git("pull", "--rebase", "origin", "HEAD")
+        self._store.git("push", "origin", "HEAD")
+
+    def create_gpg_store(self, name: str, email: str, path=None) -> str | None:
+        """
+        This method creates a GPG key and a store in the provided path. If no path is provided,
+        it will use the default store path "~/.password-store" or the "PASSWORD_STORE_DIR"
+        environment variable.
+
+        If the path already has a initialired Store, it will configure the new GPG key created and
+        then reencrypt all the existing entries.
+        """
+        if self._store.is_init():
+            return
+
+        input_data = self._gpg.gen_key_input(
+            name_real=name,
+            name_email=email,
+            key_type="RSA",
+            key_length=4096,
+            expire_date="0",
+        )
+
+        key = self._gpg.gen_key(input_data)
+        self._store.init_store(key.fingerprint, path)
+        return key.fingerprint if key else None
+
+    def export_gpg_key(
+        self, passphrase: str, output_path: str | None = None
+    ) -> str | None:
+        """
+        This method exports the GPG key associated with the store. The store must be initialised and
+        it should have only one GPG key.
+        """
+        if not self._store.is_init():
+            return
+
+        if output_path is None:
+            export_dir = Path.home() / "passtui"
+            export_dir.mkdir(exist_ok=True)
+            output_path = str(export_dir / "gpg-export.asc")
+        else:
+            output_path = str(Path(output_path).expanduser())
+            Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+        keys = _get_gpg_recipients(self._store.store_dir)
+        keys_data = self._gpg.export_keys(keys, passphrase=passphrase, secret=True)
+        if not keys_data:
+            return
+        with open(output_path, "w") as f:
+            f.write(keys_data)
+        return output_path
+
+    def import_gpg_key(self, file_path: str) -> bool:
+        """
+        Import a GPG key and use it to re-encrypt the password store.
+        """
+        if not self._store.is_init():
+            return False
+
+        input_path = str(Path(file_path).expanduser())
+        results = self._gpg.import_keys_file(input_path)
+
+        gpg_ids = results.fingerprints
+        if gpg_ids is None:
+            return False
+        if not isinstance(gpg_ids, list):
+            gpg_ids = [gpg_ids]
+
+        gpg_ids = list(dict.fromkeys(gpg_ids))
+        current_ids = _get_gpg_recipients(self._store.store_dir)
+        key_names = self.list_keys()
+        if not key_names:
+            return False
+
+        # Unlock the password store
+        try:
+            key = self.get_store_key(key_names[0])
+            if not key:
+                return False
+        except Exception:
+            return False
+
+        # Make the new key trusted
+        try:
+            self._gpg.trust_keys(gpg_ids, "TRUST_ULTIMATE")
+        except Exception:
+            return False
+
+        # Update .gpg-id
+        all_keys = list(dict.fromkeys(current_ids + gpg_ids))
+        gpg_id_path = os.path.join(self._store.store_dir, ".gpg-id")
+        with open(gpg_id_path, "w") as gpg_id_file:
+            gpg_id_file.write("\n".join(all_keys))
+            gpg_id_file.write("\n")
+
+        git_add_path(
+            self._store.repo,
+            gpg_id_path,
+            f"Set GPG id to {', '.join(all_keys)}. [{secrets.token_hex(4)}]",
+            verbose=False,
+        )
+
+        # once the newly imported key is trusted, we need to reencrypt the store.
+        # All the fingerprints listed in the in .gpg-id file need to be signed
+        reencrypt_path(
+            self._store.store_dir,
+            gpg_bin=self._store.gpg_bin,
+            gpg_opts=self._store.gpg_opts,
+        )
+
+        git_add_path(
+            self._store.repo,
+            self._store.store_dir,
+            f"Reencrypt password store using new GPG id {', '.join(all_keys)}. [{secrets.token_hex(4)}]",
+            verbose=False,
+        )
+
+        return results.count > 0
+
+
+passcli = PassCLI()