passvault-cli 0.1.0__py3-none-any.whl

passvault/__init__.py

@@ -0,0 +1,7 @@
+"""passvault — a local, encrypted, offline password manager CLI."""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+__all__ = ["__version__"]

passvault/cli.py

@@ -0,0 +1,258 @@
+"""passvault command line interface.
+
+Every command that touches the vault prompts for the master password (there is
+deliberately no session caching and no OS keychain). Decrypted material lives
+only in local variables for the duration of a command.
+"""
+
+from __future__ import annotations
+
+from typing import NoReturn, Optional
+
+import pyperclip
+import typer
+from InquirerPy import inquirer
+from rich.console import Console
+from rich.markup import escape
+from rich.table import Table
+
+from . import __version__, crypto, generator, storage
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    help="A local, encrypted, offline password manager.",
+)
+
+console = Console()
+error_console = Console(stderr=True)
+
+
+def _fail(message: str, code: int = 1) -> NoReturn:
+    """Print an error to stderr and exit non-zero."""
+    error_console.print(f"[bold red]error:[/bold red] {message}")
+    raise typer.Exit(code=code)
+
+
+# --- interactive prompt helpers -------------------------------------------------
+# These are thin wrappers so they can be monkeypatched in tests (InquirerPy needs
+# a real TTY, which Typer's CliRunner does not provide).
+
+
+def _prompt_secret(message: str) -> str:
+    return inquirer.secret(message=f"{message}:", qmark="").execute()
+
+
+def _prompt_text(message: str) -> str:
+    return inquirer.text(message=f"{message}:", qmark="").execute()
+
+
+def _prompt_confirm(message: str, default: bool = False) -> bool:
+    return inquirer.confirm(message=message, default=default, qmark="").execute()
+
+
+# --- shared vault unlock --------------------------------------------------------
+
+
+def _unlock_vault() -> tuple[dict, str]:
+    """Prompt for the master password and return ``(entries, password)``.
+
+    The password is returned so a command can hand it straight to
+    :func:`storage.save_vault`. It is never stored globally.
+    """
+    if not storage.vault_exists():
+        _fail("No vault found. Run 'passvault init' first.")
+
+    password = _prompt_secret("Master password")
+    if not password:
+        _fail("Master password cannot be empty.")
+
+    try:
+        entries = storage.load_vault(password)
+    except crypto.InvalidVaultPassword as exc:
+        _fail(str(exc))
+    except FileNotFoundError as exc:
+        _fail(str(exc))
+    return entries, password
+
+
+def _output_secret(value: str, clipboard: bool, label: str = "Generated password") -> None:
+    """Emit a secret to stdout or the clipboard, never silently."""
+    if clipboard:
+        try:
+            pyperclip.copy(value)
+        except pyperclip.PyperclipException as exc:  # pragma: no cover - env dependent
+            _fail(f"Could not copy to clipboard: {exc}")
+        console.print(f"[green]{label} copied to clipboard[/green] (not shown).")
+    else:
+        # Only reached on an explicit request to display the secret. Markup is
+        # disabled so characters like '[' in a password are printed verbatim.
+        console.print(value, markup=False, highlight=False)
+
+
+# --- commands -------------------------------------------------------------------
+
+
+@app.callback(invoke_without_command=True)
+def _main(
+    version: bool = typer.Option(
+        False, "--version", help="Show the version and exit.", is_eager=True
+    ),
+) -> None:
+    if version:
+        console.print(f"passvault {__version__}")
+        raise typer.Exit()
+
+
+@app.command()
+def init() -> None:
+    """Create a new, empty vault protected by a master password."""
+    if storage.vault_exists():
+        _fail(f"A vault already exists at {storage.vault_path()}.")
+
+    password = _prompt_secret("Choose a master password")
+    if not password:
+        _fail("Master password cannot be empty.")
+
+    confirmation = _prompt_secret("Confirm master password")
+    if password != confirmation:
+        _fail("Passwords do not match.")
+
+    storage.create_empty_vault(password)
+    console.print(f"[green]Vault created[/green] at {storage.vault_path()}")
+
+
+@app.command()
+def add(
+    name: str = typer.Argument(..., help="Name of the entry to add."),
+    generate: bool = typer.Option(
+        False, "--generate", "-g", help="Generate a password instead of prompting."
+    ),
+    length: int = typer.Option(
+        16, "--length", "-l", help="Length used with --generate."
+    ),
+    username: Optional[str] = typer.Option(
+        None, "--username", "-u", help="Username to store (skips the prompt)."
+    ),
+    notes: Optional[str] = typer.Option(
+        None, "--notes", help="Notes to store (skips the prompt)."
+    ),
+) -> None:
+    """Add or overwrite an entry."""
+    entries, password = _unlock_vault()
+
+    if name in entries:
+        if not _prompt_confirm(f"'{name}' already exists. Overwrite?", default=False):
+            _fail("Aborted; the existing entry was left unchanged.")
+
+    if generate:
+        try:
+            secret = generator.generate_password(length=length)
+        except ValueError as exc:
+            _fail(str(exc))
+    else:
+        secret = _prompt_secret(f"Password for '{name}'")
+        if not secret:
+            _fail("Password cannot be empty.")
+
+    if username is None:
+        username = _prompt_text("Username (optional)") or None
+    if notes is None:
+        notes = _prompt_text("Notes (optional)") or None
+
+    entries[name] = {"password": secret, "username": username, "notes": notes}
+    storage.save_vault(entries, password)
+    console.print(f"[green]Saved[/green] '{escape(name)}'.")
+
+
+@app.command("list")
+def list_entries() -> None:
+    """List entry names. Stored passwords are never shown."""
+    entries, _ = _unlock_vault()
+
+    if not entries:
+        console.print("Vault is empty.")
+        return
+
+    table = Table(title="passvault entries", show_lines=False)
+    table.add_column("Name", style="bold")
+    table.add_column("Username")
+    table.add_column("Notes")
+
+    for entry_name in sorted(entries):
+        record = entries[entry_name]
+        has_notes = bool(record.get("notes"))
+        table.add_row(
+            escape(entry_name),
+            escape(record.get("username") or "-"),
+            "(set)" if has_notes else "-",
+        )
+
+    console.print(table)
+
+
+@app.command()
+def get(
+    name: str = typer.Argument(..., help="Entry to retrieve."),
+    clipboard: bool = typer.Option(
+        False, "--clipboard", "-c", help="Copy to the clipboard instead of printing."
+    ),
+) -> None:
+    """Retrieve a stored password."""
+    entries, _ = _unlock_vault()
+
+    record = entries.get(name)
+    if record is None:
+        _fail(f"No entry named '{escape(name)}'.")
+
+    secret = record.get("password", "")
+    if clipboard:
+        _output_secret(secret, clipboard=True, label=f"Password for '{escape(name)}'")
+    else:
+        console.print(secret, markup=False, highlight=False)
+
+
+@app.command()
+def delete(
+    name: str = typer.Argument(..., help="Entry to delete."),
+) -> None:
+    """Delete an entry after confirmation."""
+    entries, password = _unlock_vault()
+
+    if name not in entries:
+        _fail(f"No entry named '{escape(name)}'.")
+
+    if not _prompt_confirm(f"Delete '{name}'?", default=False):
+        _fail("Aborted; nothing was deleted.")
+
+    del entries[name]
+    storage.save_vault(entries, password)
+    console.print(f"[green]Deleted[/green] '{escape(name)}'.")
+
+
+@app.command()
+def generate(
+    length: int = typer.Option(16, "--length", "-l", help="Password length."),
+    no_symbols: bool = typer.Option(
+        False, "--no-symbols", help="Exclude symbols."
+    ),
+    no_digits: bool = typer.Option(False, "--no-digits", help="Exclude digits."),
+    clipboard: bool = typer.Option(
+        False, "--clipboard", "-c", help="Copy to the clipboard instead of printing."
+    ),
+) -> None:
+    """Generate a password without touching the vault."""
+    try:
+        secret = generator.generate_password(
+            length=length,
+            use_symbols=not no_symbols,
+            use_digits=not no_digits,
+        )
+    except ValueError as exc:
+        _fail(str(exc))
+
+    _output_secret(secret, clipboard=clipboard)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

passvault/crypto.py

@@ -0,0 +1,96 @@
+"""Cryptographic primitives for passvault.
+
+Key derivation uses Argon2id (via ``argon2-cffi``) and encryption uses
+``cryptography``'s Fernet (AES-128-CBC + HMAC-SHA256, authenticated).
+
+Design notes
+------------
+* The master password is never stored. Only a salt is persisted alongside the
+  encrypted blob; the key is re-derived on every command.
+* ``derive_key`` returns a URL-safe base64 encoded 32-byte key, which is the
+  exact format Fernet expects.
+* ``decrypt`` never returns partial or garbage plaintext: any authentication
+  failure is surfaced as :class:`InvalidVaultPassword`.
+"""
+
+from __future__ import annotations
+
+import base64
+import os
+
+from argon2.low_level import Type, hash_secret_raw
+from cryptography.fernet import Fernet, InvalidToken
+
+__all__ = [
+    "InvalidVaultPassword",
+    "SALT_SIZE",
+    "generate_salt",
+    "derive_key",
+    "encrypt",
+    "decrypt",
+]
+
+#: Length of the random salt, in bytes.
+SALT_SIZE = 16
+
+#: Length of the raw derived key, in bytes (before base64 encoding for Fernet).
+KEY_SIZE = 32
+
+# Argon2id parameters. Chosen to be conservative but usable for an interactive
+# CLI on a laptop; raise these if you have cycles to spare.
+_TIME_COST = 3
+_MEMORY_COST_KIB = 64 * 1024  # 64 MiB
+_PARALLELISM = 4
+
+
+class InvalidVaultPassword(Exception):
+    """Raised when decryption fails, i.e. the master password is wrong.
+
+    Also raised when the vault file is corrupted or was encrypted with a
+    different key, because Fernet cannot distinguish those cases.
+    """
+
+
+def generate_salt() -> bytes:
+    """Return ``SALT_SIZE`` cryptographically secure random bytes."""
+    return os.urandom(SALT_SIZE)
+
+
+def derive_key(password: str, salt: bytes) -> bytes:
+    """Derive a Fernet-compatible key from ``password`` and ``salt``.
+
+    The derivation is deterministic: the same password and salt always produce
+    the same key. The result is a URL-safe base64 encoded 32-byte string, ready
+    to hand to :class:`cryptography.fernet.Fernet`.
+    """
+    if not isinstance(salt, (bytes, bytearray)) or len(salt) == 0:
+        raise ValueError("salt must be a non-empty bytes value")
+    raw = hash_secret_raw(
+        secret=password.encode("utf-8"),
+        salt=bytes(salt),
+        time_cost=_TIME_COST,
+        memory_cost=_MEMORY_COST_KIB,
+        parallelism=_PARALLELISM,
+        hash_len=KEY_SIZE,
+        type=Type.ID,
+    )
+    return base64.urlsafe_b64encode(raw)
+
+
+def encrypt(data: bytes, key: bytes) -> bytes:
+    """Encrypt ``data`` with ``key``, returning a Fernet token."""
+    return Fernet(key).encrypt(data)
+
+
+def decrypt(token: bytes, key: bytes) -> bytes:
+    """Decrypt a Fernet ``token`` with ``key``.
+
+    Raises :class:`InvalidVaultPassword` if the key is wrong or the token was
+    tampered with. This never silently returns garbage.
+    """
+    try:
+        return Fernet(key).decrypt(token)
+    except InvalidToken as exc:
+        raise InvalidVaultPassword(
+            "Incorrect master password, or the vault is corrupted."
+        ) from exc

passvault/generator.py

@@ -0,0 +1,52 @@
+"""Password generation using the :mod:`secrets` module.
+
+Everything here is cryptographically random. ``random`` is never used.
+"""
+
+from __future__ import annotations
+
+import secrets
+import string
+
+__all__ = ["generate_password", "SYMBOLS"]
+
+#: Symbols offered when ``use_symbols`` is enabled.
+SYMBOLS = "!@#$%^&*()-_=+[]{}<>?,.:;/"
+
+_LOWERCASE = string.ascii_lowercase
+_UPPERCASE = string.ascii_uppercase
+_DIGITS = string.digits
+
+
+def generate_password(
+    length: int = 16,
+    use_symbols: bool = True,
+    use_digits: bool = True,
+) -> str:
+    """Return a random password of ``length`` characters.
+
+    At least one character from every enabled class is guaranteed to appear
+    (lowercase and uppercase are always enabled).
+
+    Raises :class:`ValueError` if ``length`` is too short to include one
+    character from each requested class, or if it is not positive.
+    """
+    pools = [_LOWERCASE, _UPPERCASE]
+    if use_digits:
+        pools.append(_DIGITS)
+    if use_symbols:
+        pools.append(SYMBOLS)
+
+    if length < len(pools):
+        raise ValueError(
+            f"length must be at least {len(pools)} to include one character "
+            f"from each requested class (got {length})"
+        )
+
+    alphabet = "".join(pools)
+
+    # Rejection-sample until every requested class is represented.
+    while True:
+        password = "".join(secrets.choice(alphabet) for _ in range(length))
+        if all(any(ch in pool for ch in password) for pool in pools):
+            return password

passvault/storage.py

@@ -0,0 +1,130 @@
+"""Vault persistence.
+
+The vault is a single file containing::
+
+    salt (16 raw bytes) || Fernet token (encrypted UTF-8 JSON object)
+
+The entries themselves are a JSON object mapping entry name to a small record::
+
+    {
+        "github": {"password": "...", "username": "me", "notes": "..."},
+        ...
+    }
+
+The salt is generated once at vault creation and never rotated, so the derived
+key stays stable across saves.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from platformdirs import user_data_dir
+
+from . import crypto
+
+__all__ = [
+    "VAULT_FILENAME",
+    "vault_path",
+    "vault_exists",
+    "create_empty_vault",
+    "load_vault",
+    "save_vault",
+]
+
+VAULT_FILENAME = "vault.dat"
+
+_APP_NAME = "passvault"
+
+
+def vault_path() -> Path:
+    """Return the location of the vault file.
+
+    Overridden in tests via monkeypatch; kept as a function so no path is
+    captured at import time.
+    """
+    return Path(user_data_dir(_APP_NAME)) / VAULT_FILENAME
+
+
+def vault_exists() -> bool:
+    """Return ``True`` if a vault file is present."""
+    return vault_path().is_file()
+
+
+def _read_raw(path: Path) -> tuple[bytes, bytes]:
+    """Read the vault file and split it into ``(salt, encrypted_blob)``."""
+    try:
+        raw = path.read_bytes()
+    except FileNotFoundError as exc:
+        raise FileNotFoundError(
+            "No vault found. Run 'passvault init' first."
+        ) from exc
+
+    if len(raw) <= crypto.SALT_SIZE:
+        raise crypto.InvalidVaultPassword(
+            "Vault file is truncated or corrupted."
+        )
+    return raw[: crypto.SALT_SIZE], raw[crypto.SALT_SIZE :]
+
+
+def _write_raw(path: Path, salt: bytes, blob: bytes) -> None:
+    """Write ``salt || blob`` to ``path`` atomically."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    tmp.write_bytes(salt + blob)
+    os.replace(tmp, path)
+    # Best-effort tightening of permissions on POSIX; a no-op on Windows.
+    try:
+        os.chmod(path, 0o600)
+    except (OSError, NotImplementedError):
+        pass
+
+
+def create_empty_vault(password: str) -> None:
+    """Create a new vault protected by ``password`` with no entries."""
+    path = vault_path()
+    salt = crypto.generate_salt()
+    key = crypto.derive_key(password, salt)
+    blob = crypto.encrypt(json.dumps({}).encode("utf-8"), key)
+    _write_raw(path, salt, blob)
+
+
+def load_vault(password: str) -> dict:
+    """Decrypt and return the entries dict.
+
+    Raises :class:`crypto.InvalidVaultPassword` on a wrong password or a
+    corrupted vault.
+    """
+    salt, blob = _read_raw(vault_path())
+    key = crypto.derive_key(password, salt)
+    plaintext = crypto.decrypt(blob, key)
+    try:
+        entries = json.loads(plaintext.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise crypto.InvalidVaultPassword(
+            "Vault contents are unreadable."
+        ) from exc
+    if not isinstance(entries, dict):
+        raise crypto.InvalidVaultPassword("Vault contents are malformed.")
+    return entries
+
+
+def save_vault(entries: dict, password: str) -> None:
+    """Persist ``entries``, reusing the existing salt.
+
+    Deriving the key requires the salt, so the vault must already exist; the
+    password must be correct or decryption/encryption would be inconsistent.
+    """
+    path = vault_path()
+    salt, blob = _read_raw(path)
+    key = crypto.derive_key(password, salt)
+    # Verify the password against the current contents before overwriting.
+    # Without this, a wrong password would re-encrypt with a bogus key and
+    # silently destroy the vault.
+    crypto.decrypt(blob, key)
+    new_blob = crypto.encrypt(
+        json.dumps(entries, sort_keys=True).encode("utf-8"), key
+    )
+    _write_raw(path, salt, new_blob)

passvault_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.5
+Name: passvault-cli
+Version: 0.1.0
+Summary: A local, encrypted, offline password manager CLI.
+Project-URL: Homepage, https://github.com/Ajeet2005/passvault
+Project-URL: Repository, https://github.com/Ajeet2005/passvault
+Project-URL: Issues, https://github.com/Ajeet2005/passvault/issues
+Author: passvault contributors
+License: MIT License
+        
+        Copyright (c) 2026 passvault contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: cli,encryption,offline,password-manager,security,vault
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: argon2-cffi>=23.1
+Requires-Dist: cryptography>=42.0
+Requires-Dist: inquirerpy>=0.3.4
+Requires-Dist: platformdirs>=4.0
+Requires-Dist: pyperclip>=1.8
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# passvault
+
+A local, encrypted, offline password manager CLI.
+
+> **PyPI note:** the distribution is published as
+> [`passvault-cli`](https://pypi.org/project/passvault-cli/) because the name
+> `passvault` was already taken. The installed command and import name are
+> still `passvault`.
+
+- No network calls, no accounts, no telemetry.
+- Everything lives in a single encrypted file on your machine.
+- Your master password is required on **every** command. There is no session
+  caching and no OS keychain integration — by design.
+
+## How it works
+
+Entries are stored as a JSON object and encrypted with
+[Fernet](https://cryptography.io/en/latest/fernet/) (AES-128-CBC + HMAC-SHA256,
+authenticated encryption).
+
+The encryption key is derived from your master password with **Argon2id**
+(memory-hard, 64 MiB, 3 passes) using a random 16-byte salt.
+
+The vault file is laid out as:
+
+```
+salt (16 bytes) || Fernet token
+```
+
+The salt is generated once at vault creation and never rotated. Deriving the
+key requires the master password, which is never stored, logged, or written
+anywhere. A wrong master password fails loudly — authenticated decryption means
+we never return garbage plaintext.
+
+## Install
+
+From PyPI:
+
+```bash
+pip install passvault-cli
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Ajeet2005/passvault.git
+cd passvault
+python -m venv .venv
+# Windows: .venv\Scripts\activate
+source .venv/bin/activate
+pip install -e .
+```
+
+Requires Python 3.10+.
+
+## Usage
+
+### Create a vault
+
+```bash
+passvault init
+```
+
+Refuses to run if a vault already exists. You'll be asked for your master
+password twice.
+
+### Add an entry
+
+```bash
+passvault add github --generate --length 24 --username me@example.com
+passvault add email                 # prompt for the password (hidden input)
+```
+
+Existing entries are only overwritten after a confirmation prompt. Passwords
+are never echoed back to the terminal.
+
+### List entries
+
+```bash
+passvault list
+```
+
+Shows names, usernames, and whether notes are set. **Never** prints stored
+passwords.
+
+### Retrieve a password
+
+```bash
+passvault get github               # print the password to stdout
+passvault get github --clipboard   # copy to the clipboard, don't print it
+```
+
+The behavior is always explicit: you choose whether the secret is printed or
+copied. There is no silent default.
+
+### Delete an entry
+
+```bash
+passvault delete github
+```
+
+Asks for confirmation first.
+
+### Generate a password without a vault
+
+```bash
+passvault generate --length 32
+passvault generate --no-symbols
+passvault generate --no-digits --clipboard
+```
+
+## Vault location
+
+The vault lives in your OS's user data directory:
+
+| OS      | Path                                              |
+| ------- | ------------------------------------------------- |
+| Windows | `%LOCALAPPDATA%\passvault\vault.dat`              |
+| macOS   | `~/Library/Application Support/passvault/vault.dat` |
+| Linux   | `~/.local/share/passvault/vault.dat`              |
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest --cov=passvault
+```
+
+Test layout:
+
+- `tests/test_crypto.py` — key derivation determinism, round trips, wrong-password
+  failure.
+- `tests/test_storage.py` — create/load/save round trips, salt persistence,
+  refusing writes on a wrong password.
+- `tests/test_generator.py` — length and character-class guarantees.
+- `tests/test_cli.py` — end-to-end command tests via Typer's `CliRunner`.
+
+## Security notes
+
+- The master password is never stored, in any form.
+- Decrypted passwords are only printed when you explicitly run `get` without
+  `--clipboard`.
+- All randomness uses Python's `secrets` module, never `random`.
+- A wrong master password always fails loudly.
+- No session caching and no OS keychain support in this version.
+
+## Disclaimer
+
+This is a learning project. It has **not** been audited. For real secrets, use a
+battle-tested password manager.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

passvault_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+passvault/__init__.py,sha256=dlE_EqIzDbo5x5P6vlP3shdFEOqlPWfVGDkKMSIxZIg,156
+passvault/cli.py,sha256=mQb8-r_f5q7dpIn_R3xlXvppL7YwohiDZ46yOIafQQw,8080
+passvault/crypto.py,sha256=J8mvmlOsct6QzgphgjU50egJbi_69Mam1SYGAV79iFo,3015
+passvault/generator.py,sha256=QLg0VpbHte4zQcCryw3h4XCYvowKB6hNBcjfSDkrjKM,1505
+passvault/storage.py,sha256=zwpVXqfx7_-dOVpPHOlkR2J713ClVhetkMuACHROLJE,3821
+passvault_cli-0.1.0.dist-info/METADATA,sha256=Nw9gVvZlyFnKS6Wt9ZVJhgGi5KLsebZ1JYlUvtns0YY,6612
+passvault_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+passvault_cli-0.1.0.dist-info/entry_points.txt,sha256=qXq0s2RfhPeOqYvJTARFWb_ArI0xVWrv1DUFogC73No,48
+passvault_cli-0.1.0.dist-info/licenses/LICENSE,sha256=l9n3TmFv8BEN1nx5I2aseQ3497tFG5s_pkl5oaN1n-8,1079
+passvault_cli-0.1.0.dist-info/RECORD,,

passvault_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

passvault_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+passvault = passvault.cli:app

passvault_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 passvault contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.