edgevault 0.5.0__py3-none-any.whl

edgevault/__init__.py

@@ -0,0 +1,21 @@
+"""edgevault — зашифрованные бэкапы баз, файлов и секретов.
+
+Как библиотека — в коде проекта (см. edgevault.vault):
+
+    from edgevault import Vault, Postgres, Secrets, S3, Telegram
+
+Как программа — `edgevault init` и один конфиг edgevault.toml на проект.
+"""
+
+__version__ = "0.5.0"
+
+from edgevault.config import Files, Keep, Mirror, Postgres, Secrets, Sqlite
+from edgevault.destinations import S3, Folder, Rclone
+from edgevault.errors import ConfigError
+from edgevault.report import Problem, Report
+from edgevault.vault import Telegram, Vault, Webhook
+
+__all__ = [
+    "S3", "ConfigError", "Files", "Folder", "Keep", "Mirror", "Postgres", "Problem",
+    "Rclone", "Report", "Secrets", "Sqlite", "Telegram", "Vault", "Webhook", "__version__",
+]  # fmt: skip

edgevault/__main__.py

@@ -0,0 +1,3 @@
+from edgevault.cli import main
+
+main()

edgevault/age.py

@@ -0,0 +1,268 @@
+"""Формат age (https://age-encryption.org/v1) на Python: без программы age.
+
+Копии, зашифрованные здесь, расшифровывает обычный `age -d`, и наоборот. Нужна
+только библиотека `cryptography`. Поддерживаются ключи X25519 — те, что делает
+`age-keygen` (`age1…` и `AGE-SECRET-KEY-1…`).
+
+Шифруем потоком, кусками по 64 КиБ: дамп любого размера не читается в память.
+"""
+
+from __future__ import annotations
+
+import base64
+import datetime
+import hmac
+import os
+from collections.abc import Iterator, Sequence
+from hashlib import sha256
+from pathlib import Path
+from typing import BinaryIO
+
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
+
+INTRO = b"age-encryption.org/v1\n"
+CHUNK = 64 * 1024
+_TAG = 16
+_X25519_INFO = b"age-encryption.org/v1/X25519"
+PUBLIC_HRP = "age"
+SECRET_HRP = "age-secret-key-"
+
+
+class AgeError(ValueError):
+    """Ключ не тот, файл не age или повреждён."""
+
+
+# ─── bech32 (BIP 173): в нём записаны ключи age ──────────────────────────────
+
+_CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+
+
+def _polymod(values: Sequence[int]) -> int:
+    generator = (0x3B6A57B2, 0x26508E6D, 0x1EA119FA, 0x3D4233DD, 0x2A1462B3)
+    check = 1
+    for value in values:
+        top = check >> 25
+        check = (check & 0x1FFFFFF) << 5 ^ value
+        for i in range(5):
+            check ^= generator[i] if (top >> i) & 1 else 0
+    return check
+
+
+def _hrp_expand(hrp: str) -> list[int]:
+    return [ord(c) >> 5 for c in hrp] + [0] + [ord(c) & 31 for c in hrp]
+
+
+def _convert(data: Sequence[int], source: int, target: int, pad: bool) -> list[int]:
+    acc = bits = 0
+    out = []
+    mask = (1 << target) - 1
+    for value in data:
+        acc = (acc << source) | value
+        bits += source
+        while bits >= target:
+            bits -= target
+            out.append((acc >> bits) & mask)
+    if pad and bits:
+        out.append((acc << (target - bits)) & mask)
+    elif not pad and (bits >= source or (acc << (target - bits)) & mask):
+        raise AgeError("ключ повреждён: лишние биты")
+    return out
+
+
+def bech32_encode(hrp: str, data: bytes) -> str:
+    words = _convert(data, 8, 5, pad=True)
+    polymod = _polymod([*_hrp_expand(hrp), *words, 0, 0, 0, 0, 0, 0]) ^ 1
+    checksum = [(polymod >> 5 * (5 - i)) & 31 for i in range(6)]
+    return hrp + "1" + "".join(_CHARSET[w] for w in [*words, *checksum])
+
+
+def bech32_decode(text: str) -> tuple[str, bytes]:
+    if text.lower() != text and text.upper() != text:
+        raise AgeError("ключ повреждён: смешаны регистры")
+    text = text.lower()
+    hrp, sep, rest = text.rpartition("1")
+    if not sep or not hrp or len(rest) < 6 or any(c not in _CHARSET for c in rest):
+        raise AgeError("это не ключ age")
+    words = [_CHARSET.index(c) for c in rest]
+    if _polymod([*_hrp_expand(hrp), *words]) != 1:
+        raise AgeError("ключ повреждён: не сходится контрольная сумма — опечатка?")
+    return hrp, bytes(_convert(words[:-6], 5, 8, pad=False))
+
+
+# ─── Ключи ───────────────────────────────────────────────────────────────────
+
+
+def _raw_public(key: X25519PublicKey) -> bytes:
+    return key.public_bytes(Encoding.Raw, PublicFormat.Raw)
+
+
+def parse_recipient(text: str) -> X25519PublicKey:
+    """Открытый ключ `age1…`."""
+    hrp, data = bech32_decode(text.strip())
+    if hrp != PUBLIC_HRP or len(data) != 32:
+        raise AgeError(f"«{text[:12]}…» — не открытый ключ age (age1…)")
+    return X25519PublicKey.from_public_bytes(data)
+
+
+def parse_identity(text: str) -> X25519PrivateKey:
+    """Закрытый ключ `AGE-SECRET-KEY-1…`."""
+    hrp, data = bech32_decode(text.strip())
+    if hrp != SECRET_HRP or len(data) != 32:
+        raise AgeError("это не закрытый ключ age (AGE-SECRET-KEY-1…)")
+    return X25519PrivateKey.from_private_bytes(data)
+
+
+def read_identities(path: Path) -> list[X25519PrivateKey]:
+    """Файл ключей, как его пишет age-keygen: комментарии и строки AGE-SECRET-KEY-1…"""
+    keys = [
+        parse_identity(line)
+        for line in path.read_text(encoding="utf-8").splitlines()
+        if line.strip() and not line.startswith("#")
+    ]
+    if not keys:
+        raise AgeError(f"в {path} нет закрытого ключа AGE-SECRET-KEY-1…")
+    return keys
+
+
+def generate() -> tuple[str, str]:
+    """Новая пара ключей: (закрытый AGE-SECRET-KEY-1…, открытый age1…)."""
+    secret = X25519PrivateKey.generate()
+    raw = secret.private_bytes_raw()
+    return (
+        bech32_encode(SECRET_HRP, raw).upper(),
+        bech32_encode(PUBLIC_HRP, _raw_public(secret.public_key())),
+    )
+
+
+def key_file(secret: str, public: str) -> str:
+    """Текст файла ключа в формате age-keygen."""
+    created = datetime.datetime.now().astimezone().isoformat(timespec="seconds")
+    return f"# created: {created}\n# public key: {public}\n{secret}\n"
+
+
+# ─── Шифрование ──────────────────────────────────────────────────────────────
+
+
+def _hkdf(ikm: bytes, salt: bytes, info: bytes) -> bytes:
+    return HKDF(algorithm=SHA256(), length=32, salt=salt, info=info).derive(ikm)
+
+
+def _b64(data: bytes) -> bytes:
+    return base64.b64encode(data).rstrip(b"=")
+
+
+def _unb64(data: bytes) -> bytes:
+    if data.endswith(b"=") or b"\n" in data:
+        raise AgeError("файл age повреждён: неверная запись base64")
+    return base64.b64decode(data + b"=" * (-len(data) % 4), validate=True)
+
+
+def _stanza(recipient: X25519PublicKey, file_key: bytes) -> bytes:
+    ephemeral = X25519PrivateKey.generate()
+    share = _raw_public(ephemeral.public_key())
+    shared = ephemeral.exchange(recipient)
+    wrap = _hkdf(shared, share + _raw_public(recipient), _X25519_INFO)
+    body = ChaCha20Poly1305(wrap).encrypt(b"\x00" * 12, file_key, None)
+    return b"-> X25519 " + _b64(share) + b"\n" + _b64(body) + b"\n"
+
+
+def _nonce(counter: int, last: bool) -> bytes:
+    return counter.to_bytes(11, "big") + (b"\x01" if last else b"\x00")
+
+
+def _chunks(source: BinaryIO, size: int) -> Iterator[tuple[bytes, bool]]:
+    """Куски по `size` байт с пометкой «последний» (нужен заглядывать на шаг вперёд)."""
+    current = source.read(size)
+    while True:
+        following = source.read(size)
+        yield current, not following
+        if not following:
+            return
+        current = following
+
+
+def encrypt_stream(source: BinaryIO, sink: BinaryIO, recipients: Sequence[str]) -> None:
+    if not recipients:
+        raise AgeError("нет открытого ключа: шифровать нечем")
+    keys = [parse_recipient(r) for r in recipients]
+    file_key = os.urandom(16)
+    header = INTRO + b"".join(_stanza(k, file_key) for k in keys) + b"---"
+    mac = hmac.new(_hkdf(file_key, b"", b"header"), header, sha256).digest()
+    sink.write(header + b" " + _b64(mac) + b"\n")
+    nonce = os.urandom(16)
+    sink.write(nonce)
+    cipher = ChaCha20Poly1305(_hkdf(file_key, nonce, b"payload"))
+    for counter, (chunk, last) in enumerate(_chunks(source, CHUNK)):
+        sink.write(cipher.encrypt(_nonce(counter, last), chunk, None))
+
+
+def decrypt_stream(
+    source: BinaryIO, sink: BinaryIO, identities: Sequence[X25519PrivateKey]
+) -> None:
+    intro = source.readline()
+    if intro != INTRO:
+        raise AgeError("это не файл age")
+    header = intro
+    file_key = None
+    while True:
+        line = source.readline()
+        if not line:
+            raise AgeError("файл age обрезан: нет конца заголовка")
+        if line.startswith(b"---"):
+            header += b"---"
+            mac = _unb64(line[4:].rstrip(b"\n"))
+            break
+        header += line
+        if not line.startswith(b"-> "):
+            raise AgeError("файл age повреждён: неверный заголовок")
+        args = line[3:].rstrip(b"\n").split(b" ")
+        body = b""
+        while True:  # тело записи — строки по 64 символа, последняя короче
+            part = source.readline()
+            header += part
+            body += part.rstrip(b"\n")
+            if len(part.rstrip(b"\n")) < 64:
+                break
+        if args[0] != b"X25519" or len(args) != 2 or file_key is not None:
+            continue
+        share = _unb64(args[1])
+        wrapped = _unb64(body)
+        for identity in identities:
+            try:
+                shared = identity.exchange(X25519PublicKey.from_public_bytes(share))
+            except ValueError:
+                continue
+            wrap = _hkdf(shared, share + _raw_public(identity.public_key()), _X25519_INFO)
+            try:
+                file_key = ChaCha20Poly1305(wrap).decrypt(b"\x00" * 12, wrapped, None)
+                break
+            except Exception:
+                continue
+    if file_key is None:
+        raise AgeError("ни один ключ не подошёл: копия зашифрована другим ключом")
+    expected = hmac.new(_hkdf(file_key, b"", b"header"), header, sha256).digest()
+    if not hmac.compare_digest(expected, mac):
+        raise AgeError("заголовок файла age повреждён или подменён")
+    nonce = source.read(16)
+    if len(nonce) != 16:
+        raise AgeError("файл age обрезан")
+    cipher = ChaCha20Poly1305(_hkdf(file_key, nonce, b"payload"))
+    for counter, (chunk, last) in enumerate(_chunks(source, CHUNK + _TAG)):
+        try:
+            sink.write(cipher.decrypt(_nonce(counter, last), chunk, None))
+        except Exception as exc:
+            raise AgeError("файл age повреждён или обрезан") from exc
+
+
+def encrypt_file(plain: Path, target: Path, recipients: Sequence[str]) -> None:
+    with plain.open("rb") as source, target.open("wb") as sink:
+        encrypt_stream(source, sink, recipients)
+
+
+def decrypt_file(encrypted: Path, target: Path, identities: Sequence[X25519PrivateKey]) -> None:
+    with encrypted.open("rb") as source, target.open("wb") as sink:
+        decrypt_stream(source, sink, identities)

edgevault/cli.py

@@ -0,0 +1,311 @@
+"""edgevault — зашифрованные бэкапы баз, файлов и секретов.
+
+Подключить к проекту:  edgevault init → edgevault check → edgevault run
+Конфиг — `-c путь`, переменная EDGEVAULT_CONFIG или ./edgevault.toml.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from edgevault import __version__, age, crypto, notify, pull, runner, scaffold, schedule, tools
+from edgevault.config import Config, load
+from edgevault.errors import ConfigError
+from edgevault.report import describe
+from edgevault.sources import postgres, sqlite
+
+
+def _config(args: argparse.Namespace) -> Config:
+    path = args.config or os.environ.get("EDGEVAULT_CONFIG") or "edgevault.toml"
+    return load(path)
+
+
+def cmd_run(args: argparse.Namespace) -> int:
+    config = _config(args)
+    report = runner.run(config)
+    print(describe(report), flush=True)
+    return 0 if report.ok else 1
+
+
+def cmd_daemon(args: argparse.Namespace) -> int:
+    config = _config(args)
+    print(
+        f"edgevault {__version__}: {config.name}, бэкап каждый день в {', '.join(config.schedule)}",
+        flush=True,
+    )
+    while True:
+        time.sleep(schedule.seconds_until(config.schedule, datetime.datetime.now()))
+        report = runner.run(config)  # не падает: любой сбой — в отчёт и в сообщение
+        print(describe(report), flush=True)
+
+
+def cmd_pull(args: argparse.Namespace) -> int:
+    config = _config(args)
+    if config.pull is None:
+        raise ConfigError("В конфиге нет раздела [pull]: откуда забирать копии")
+    if args.once:
+        problems = pull.once(config)
+        for problem in problems:
+            print(problem, flush=True)
+        return 1 if problems else 0
+    print(f"Забираю копии каждые {config.pull.every_minutes} мин в {config.pull.dest}", flush=True)
+    pull.watch(config)
+    return 0
+
+
+def cmd_check(args: argparse.Namespace) -> int:
+    """Проверить конфиг и показать, что будет сохраняться. Базы только читаются."""
+    config = _config(args)
+    ok = True
+    print(f"edgevault {__version__} · проект {config.name} · копии в {config.store}")
+    lacking = {p.where: p for p in tools.missing(config)}
+    for tool in tools.required(config):
+        if tool in lacking:
+            print(f"  ✗ {tool} — {lacking[tool].error}\n    → {lacking[tool].hint}")
+            ok = False
+        else:
+            print(f"  ✓ {tool}")
+    for settings in config.postgres:
+        try:
+            found_pg = postgres.find(settings)
+        except Exception as exc:
+            print(f"  ✗ Postgres: {exc}")
+            ok = False
+            continue
+        for target in found_pg.targets:
+            print(f"  · Postgres {target.label}")
+        for where, error in found_pg.failures:
+            print(f"  ✗ Postgres {where}: {error}")
+            ok = False
+    for item in config.sqlite:
+        try:
+            for path in sqlite.files(item):
+                print(f"  · SQLite {path}")
+        except Exception as exc:
+            print(f"  ✗ {exc}")
+            ok = False
+    for folder in config.files:
+        exists = Path(folder.path).is_dir()
+        print(f"  {'·' if exists else '✗'} папка {folder.path}{'' if exists else ' — нет'}")
+        ok = ok and exists
+    if config.secrets:
+        print(f"  · секреты из {config.secrets.root}: {', '.join(config.secrets.patterns)}")
+    for place in config.all_destinations:
+        error = place.probe() if hasattr(place, "probe") else ""
+        print(f"  {'✗' if error else '→'} {place.label}{' — ' + error if error else ''}")
+        ok = ok and not error
+    if not config.all_destinations:
+        print("  ! мест хранения нет: копии только на этой машине")
+    for settings in config.postgres:
+        if problem := tools.pg_dump_version_problem(settings):
+            print(f"  ✗ {problem.where}: {problem.error}\n    → {problem.hint}")
+            ok = False
+    if config.notify.enabled:
+        places: list[str] = []
+        if config.notify.telegram_chats:
+            places.append(f"Telegram {', '.join(config.notify.telegram_chats)}")
+        if config.notify.webhook:
+            places.append("webhook")
+        print(
+            f"  ✉ сообщения: {' и '.join(places)} от «{notify.server_name(config.notify)}»"
+            " — проверить: edgevault test-notify"
+        )
+        for line in notify.proxies(config.notify):
+            print(f"    {line}")
+    else:
+        print("  ! сообщений нет: о сбое бэкапа никто не узнает — заполните [notify]")
+    print(f"  расписание: {', '.join(config.schedule)}")
+    last = config.store / "last-run.txt"
+    if last.is_file():
+        print(f"  последний прогон: {last.read_text(encoding='utf-8').strip()}")
+    return 0 if ok else 1
+
+
+def cmd_test_notify(args: argparse.Namespace) -> int:
+    config = _config(args)
+    if not config.notify.enabled:
+        raise ConfigError("[notify] пуст: задайте telegram_token и telegram_chat или webhook")
+    errors = notify.deliver(config.notify, notify.test_message())
+    for line in notify.proxies(config.notify):
+        print(f"  {line}")
+    print("Не ушло: " + "; ".join(errors) if errors else "Отправлено — проверьте чат")
+    return 1 if errors else 0
+
+
+def cmd_init(args: argparse.Namespace) -> int:
+    """Посмотреть на проект и написать для него конфиг."""
+    root = Path(args.dir).resolve()
+    target = root / "edgevault.toml"
+    if target.exists() and not args.force:
+        raise ConfigError(f"{target} уже есть — не перезаписываю (--force, если нужно)")
+    project = scaffold.scan(root)
+    target.write_text(scaffold.render_config(project), encoding="utf-8")
+
+    print(f"Готово: {target}\n")
+    print("Нашлось:")
+    for db in project.databases:
+        state = "включён" if db.running else "база не запущена здесь — в конфиге закомментирована"
+        print(f"  · Postgres {', '.join(db.services)} из {db.file} (проект {db.project}): {state}")
+    if not project.databases:
+        print("  · Postgres в compose-файлах не найден")
+    for path in project.sqlite:
+        print(f"  · SQLite {path}")
+    for env in project.env_files:
+        print(f"  · секреты {env}")
+    if project.folders:
+        print(f"  ? папки {', '.join(project.folders)} — включите в конфиге, если нужны")
+    print("\nДальше:")
+    print("  1. На СВОЁМ компьютере: edgevault keygen — ключ age-key.txt в менеджер паролей")
+    env_path = root / ".env"
+    print(f"  2. В {env_path}{'' if env_path.exists() else ' (создайте его)'}:")
+    for line in scaffold.env_variables(project):
+        print(f"       {line}")
+    print("  3. Вписать места хранения (targets, [remotes]) в edgevault.toml")
+    print("  4. edgevault check && edgevault test-notify && edgevault run")
+    print("  5. Запускать по расписанию — одно из:")
+    if project.compose_file:
+        print(f"     а) сервис в {project.compose_file.name}:\n")
+        print(scaffold.compose_service(project))
+        print()
+        print("     б) без Docker: sudo edgevault systemd --install")
+    else:
+        print("     sudo edgevault systemd --install")
+    print("\nВ .gitignore: backups/  ·  age-key.txt (а конфиг можно хранить в git)")
+    return 0
+
+
+def cmd_systemd(args: argparse.Namespace) -> int:
+    """Таймер systemd: бэкап по расписанию из конфига без Docker и без cron."""
+    config = _config(args)
+    path = Path(args.config or os.environ.get("EDGEVAULT_CONFIG") or "edgevault.toml").resolve()
+    units = scaffold.systemd_units(config.name, path, config.schedule)
+    if not args.install:
+        for name, text in units.items():
+            print(f"# /etc/systemd/system/{name}\n{text}")
+        print("Установить: sudo edgevault -c " + str(path) + " systemd --install")
+        return 0
+    folder = Path("/etc/systemd/system")
+    for name, text in units.items():
+        (folder / name).write_text(text, encoding="utf-8")
+        print(f"Записан {folder / name}")
+    timer = next(name for name in units if name.endswith(".timer"))
+    subprocess.run(["systemctl", "daemon-reload"], check=True)
+    subprocess.run(["systemctl", "enable", "--now", timer], check=True)
+    print(f"Включён {timer}. Журнал: journalctl -u {timer.removesuffix('.timer')}.service")
+    return 0
+
+
+def cmd_keygen(args: argparse.Namespace) -> int:
+    public = crypto.keygen(Path(args.path))
+    print(f"Закрытый ключ: {args.path} — в менеджер паролей, на сервер его НЕ кладут.")
+    print(f"Открытый ключ для age_recipients:\n{public}")
+    return 0
+
+
+def cmd_decrypt(args: argparse.Namespace) -> int:
+    """Расшифровать копию закрытым ключом. Ничего не перезаписывает без --force."""
+    source = Path(args.file)
+    if args.output:
+        out = Path(args.output)
+    elif source.suffix == ".age":
+        out = source.with_suffix("")
+    else:
+        raise ConfigError(f"{source} без .age в конце: укажите, куда расшифровать (-o)")
+    if out.resolve() == source.resolve():
+        raise ConfigError("Расшифровка поверх самой копии: укажите другой -o")
+    if out.exists() and not args.force:
+        raise ConfigError(f"{out} уже есть — не перезаписываю (--force, если нужно)")
+    try:
+        crypto.decrypt(source, out, Path(args.key))
+    except (age.AgeError, OSError) as exc:
+        print(f"Не расшифровалось: {exc}", file=sys.stderr)
+        return 1
+    print(f"Готово: {out}")
+    return 0
+
+
+#: Облака со входом через браузер: имя в команде → тип rclone и флаги входа.
+#: Google Диск — с доступом только к своим файлам (drive.file): программа видит
+#: лишь то, что сама положила, а не весь Диск владельца.
+AUTHORIZE: dict[str, tuple[str, list[str], str]] = {
+    "gdrive": ("drive", ["--drive-scope", "drive.file"], "GDRIVE_TOKEN"),
+    "yandex": ("yandex", [], "YADISK_TOKEN"),
+}
+
+
+def authorize_command(provider: str) -> list[str]:
+    kind, flags, _ = AUTHORIZE[provider]
+    return ["rclone", "authorize", kind, *flags]
+
+
+def cmd_authorize(args: argparse.Namespace) -> int:
+    """Получить токен облака. Делать на своём компьютере: откроется вход в браузере."""
+    if not shutil.which("rclone"):
+        raise ConfigError("Нет программы rclone: https://rclone.org/install/")
+    _, _, variable = AUTHORIZE[args.provider]
+    print('Сейчас откроется вход в браузере. После входа здесь появится строка {"access_token":…}')
+    print(f"Её целиком — в переменную {variable} в .env на сервере.\n", flush=True)
+    return subprocess.run(authorize_command(args.provider)).returncode
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="edgevault", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    parser.add_argument("--version", action="version", version=f"edgevault {__version__}")
+    parser.add_argument("-c", "--config", help="путь к конфигу (по умолчанию ./edgevault.toml)")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    init = sub.add_parser("init", help="подключить к проекту: написать конфиг по папке проекта")
+    init.add_argument("dir", nargs="?", default=".", help="папка проекта (по умолчанию текущая)")
+    init.add_argument("--force", action="store_true", help="перезаписать edgevault.toml")
+    init.set_defaults(func=cmd_init)
+    sub.add_parser("check", help="проверить конфиг и показать, что сохраняется").set_defaults(
+        func=cmd_check
+    )
+    sub.add_parser("test-notify", help="прислать проверочное сообщение").set_defaults(
+        func=cmd_test_notify
+    )
+    sub.add_parser("run", help="сделать бэкап сейчас (для cron/systemd)").set_defaults(func=cmd_run)
+    sub.add_parser("daemon", help="работать постоянно, по расписанию").set_defaults(func=cmd_daemon)
+    systemd = sub.add_parser("systemd", help="таймер systemd по расписанию из конфига")
+    systemd.add_argument("--install", action="store_true", help="записать и включить (sudo)")
+    systemd.set_defaults(func=cmd_systemd)
+    pull_parser = sub.add_parser("pull", help="забирать копии к себе")
+    pull_parser.add_argument("--once", action="store_true", help="один раз и выйти")
+    pull_parser.set_defaults(func=cmd_pull)
+    keygen = sub.add_parser("keygen", help="новая пара ключей age")
+    keygen.add_argument("path", nargs="?", default="age-key.txt")
+    keygen.set_defaults(func=cmd_keygen)
+    decrypt = sub.add_parser("decrypt", help="расшифровать копию")
+    decrypt.add_argument("file")
+    decrypt.add_argument("-k", "--key", default="age-key.txt", help="закрытый ключ")
+    decrypt.add_argument("-o", "--output")
+    decrypt.add_argument("--force", action="store_true", help="перезаписать готовый файл")
+    decrypt.set_defaults(func=cmd_decrypt)
+    authorize = sub.add_parser("authorize", help="токен Google Диска или Яндекс Диска")
+    authorize.add_argument("provider", choices=sorted(AUTHORIZE))
+    authorize.set_defaults(func=cmd_authorize)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = build_parser().parse_args(argv)
+    try:
+        sys.exit(args.func(args))
+    except ConfigError as exc:
+        print(f"Ошибка: {exc}", file=sys.stderr)
+        sys.exit(2)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()