her-sync 0.3.0__py3-none-any.whl

her_sync/cli.py

@@ -0,0 +1,407 @@
+"""her CLI (her-sync)."""
+
+from __future__ import annotations
+
+import os
+import signal
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from her_sync.cli_helpers import group_typer
+from her_sync.config import (
+    PluginDisabledError,
+    get_profile,
+    load_bde_settings,
+    load_caldav_settings,
+    load_email_settings,
+    runtime_context,
+)
+from her_sync.daemon import run_daemon
+from her_sync.migrate import migrate_from_env
+from her_sync.plugins import bde, caldav, email
+from her_sync.profile import (
+    CONFIG_DIR,
+    config_file,
+    init_profile,
+    list_profiles,
+    load_profile,
+)
+from her_sync.secrets import (
+    SecretError,
+    delete_secret,
+    has_secret,
+    migrate_legacy_keyring,
+    set_secret,
+)
+from her_sync.share.layout import ShareLayout
+
+app = typer.Typer(
+    name="her",
+    help="Linux-native Sync-Tool für Agent-Share-Filesysteme.",
+    no_args_is_help=True,
+)
+profile_app = group_typer(help="Profile verwalten")
+secrets_app = group_typer(help="Secrets im System-Keyring")
+daemon_app = group_typer(help="Watcher-Daemon")
+
+app.add_typer(profile_app, name="profile")
+app.add_typer(secrets_app, name="secrets")
+app.add_typer(daemon_app, name="daemon")
+app.add_typer(bde.app, name="bde")
+app.add_typer(email.app, name="email")
+app.add_typer(caldav.app, name="caldav")
+
+console = Console()
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    profile: str | None = typer.Option(
+        None,
+        "--profile",
+        "-p",
+        help="Profilname (Default: ~/.her/config.yml)",
+        envvar="HER_PROFILE",
+    ),
+) -> None:
+    ctx.ensure_object(dict)
+    ctx.obj["profile"] = profile
+
+
+@profile_app.command("list")
+def profile_list() -> None:
+    """Alle Profile unter ~/.her/profiles/ auflisten."""
+    names = list_profiles()
+    if not names:
+        console.print(f"[dim]Keine Profile in {CONFIG_DIR / 'profiles'}[/]")
+        return
+    default = None
+    if config_file().exists():
+        default = (yaml.safe_load(config_file().read_text()) or {}).get("default_profile")
+    for name in names:
+        mark = " (default)" if name == default else ""
+        console.print(f"  {name}{mark}")
+
+
+@profile_app.command("show")
+def profile_show(name: str) -> None:
+    """Profil-Konfiguration als YAML anzeigen."""
+    profile = load_profile(name)
+    console.print(yaml.safe_dump({"name": profile.name, **profile.as_dict()}, allow_unicode=True))
+
+
+@profile_app.command("init")
+def profile_init(
+    name: str,
+    share: Path | None = typer.Option(None, help="Share-Zielverzeichnis"),
+    force: bool = typer.Option(False, "--force"),
+) -> None:
+    """Neues Profil mit Vorlage anlegen."""
+    path = init_profile(name, share=share, force=force)
+    console.print(f"[green]Profil angelegt:[/] {path}")
+    console.print(f"[dim]Secrets setzen: her secrets set {name}/bde-password[/]")
+
+
+@profile_app.command("migrate-env")
+def profile_migrate_env(
+    name: str = typer.Option("bde-work", "--name", "-n", help="Profilname"),
+    env_file: Path = typer.Option(
+        Path(".env"),
+        "--env-file",
+        help="Pfad zur Legacy-.env",
+    ),
+    store_secrets: bool = typer.Option(
+        True,
+        "--store-secrets/--plain-secrets",
+        help="Passwörter in Keyring (empfohlen) vs. Klartext in profile.yml",
+    ),
+    force: bool = typer.Option(False, "--force", help="Bestehendes Profil überschreiben"),
+) -> None:
+    """Legacy-.env nach ~/.her/profiles/NAME/ migrieren."""
+    try:
+        result = migrate_from_env(
+            env_file,
+            name,
+            store_secrets=store_secrets,
+            force=force,
+        )
+    except FileExistsError as exc:
+        console.print(f"[red]{exc}[/]")
+        raise typer.Exit(code=1) from exc
+
+    console.print(f"[green]Profil migriert:[/] {result.profile_path}")
+    console.print(f"  Share: {result.share_root}")
+    if result.secrets_stored:
+        console.print(f"  Keyring: {', '.join(result.secrets_stored)}")
+    for path in result.filters_copied:
+        console.print(f"  Filter kopiert: {path}")
+    if result.cookies_migrated:
+        console.print("  BDE-Cookies migriert → state/")
+    for warning in result.warnings:
+        console.print(f"[yellow]Warnung:[/] {warning}")
+    console.print(f"[dim]Test: her --profile {name} status[/]")
+
+
+@profile_app.command("validate")
+def profile_validate(name: str | None = typer.Argument(None)) -> None:
+    """Profil laden und Secrets prüfen."""
+    profile = load_profile(name)
+    table = Table(title=f"Profil {profile.name}")
+    table.add_column("Check")
+    table.add_column("Status")
+
+    table.add_row("config", f"{len(profile.config_sources)} YAML-Fragmente")
+    for source in profile.config_sources:
+        table.add_row(f"  {source.name}", "OK")
+    table.add_row("share", str(profile.share_root))
+
+    for plugin in ("bde", "email", "caldav"):
+        if plugin not in profile.plugin_configs:
+            table.add_row(f"plugin:{plugin}", "[dim]disabled (kein Key)[/]")
+            continue
+        enabled = profile.is_enabled(plugin)
+        table.add_row(f"plugin:{plugin}", "enabled" if enabled else "disabled")
+
+    def _collect_keyring_refs(obj: object) -> list[str]:
+        refs: list[str] = []
+        if isinstance(obj, dict):
+            ref = obj.get("keyring")
+            if isinstance(ref, str):
+                refs.append(ref)
+            for value in obj.values():
+                refs.extend(_collect_keyring_refs(value))
+        elif isinstance(obj, list):
+            for item in obj:
+                refs.extend(_collect_keyring_refs(item))
+        return refs
+
+    loaders = {
+        "bde": load_bde_settings,
+        "email": load_email_settings,
+        "caldav": load_caldav_settings,
+    }
+    failed = False
+    for plugin, loader in loaders.items():
+        if not profile.is_enabled(plugin):
+            continue
+        try:
+            loader(profile.name)
+            table.add_row(f"load:{plugin}", "[green]OK[/]")
+        except SecretError as exc:
+            table.add_row(f"load:{plugin}", f"[red]{exc}[/]")
+            failed = True
+        except PluginDisabledError:
+            table.add_row(f"load:{plugin}", "[dim]disabled[/]")
+
+    if profile.is_enabled("email"):
+        email_filters = profile.plugin_config("email").get("filters")
+        if isinstance(email_filters, list):
+            table.add_row("email_filters", f"{len(email_filters)} inline")
+        elif isinstance(email_filters, str):
+            path = profile.profile_dir / email_filters
+            table.add_row("email_filters", "OK" if path.exists() else "[red]fehlt[/]")
+        else:
+            table.add_row("email_filters", "[red]fehlt[/]")
+
+    if profile.is_enabled("caldav"):
+        caldav = profile.plugin_config("caldav")
+        if "calendars" in caldav:
+            table.add_row("calendar_filters", f"{len(caldav.get('calendars', []))} inline")
+        elif isinstance(caldav.get("filters"), str):
+            path = profile.profile_dir / caldav["filters"]
+            table.add_row("calendar_filters", "OK" if path.exists() else "[red]fehlt[/]")
+        else:
+            table.add_row("calendar_filters", "[red]fehlt[/]")
+
+    console.print(table)
+    if failed:
+        raise typer.Exit(code=1)
+
+
+@secrets_app.command("set")
+def secrets_set(ref: str) -> None:
+    """Secret im Keyring speichern (Passwort interaktiv)."""
+    value = typer.prompt("Wert", hide_input=True)
+    set_secret(ref, value)
+    console.print(f"[green]Gespeichert:[/] her-sync / {ref}")
+
+
+@secrets_app.command("delete")
+def secrets_delete(ref: str) -> None:
+    """Secret aus dem Keyring entfernen."""
+    if delete_secret(ref):
+        console.print(f"[green]Gelöscht:[/] {ref}")
+    else:
+        console.print(f"[yellow]Nicht gefunden:[/] {ref}")
+
+
+@secrets_app.command("test")
+def secrets_test(ref: str) -> None:
+    """Prüfen ob ein Keyring-Eintrag existiert."""
+    if has_secret(ref):
+        console.print(f"[green]OK[/] {ref}")
+    else:
+        console.print(f"[red]Fehlt[/] {ref}")
+        raise typer.Exit(code=1)
+
+
+@secrets_app.command("migrate-legacy")
+def secrets_migrate_legacy(ctx: typer.Context) -> None:
+    """Keyring-Einträge von agent-sync nach her-sync kopieren (einmalig)."""
+    profile = load_profile(ctx.obj.get("profile") if ctx.obj else None)
+
+    def _refs(obj: object) -> list[str]:
+        refs: list[str] = []
+        if isinstance(obj, dict):
+            ref = obj.get("keyring")
+            if isinstance(ref, str):
+                refs.append(ref)
+            for value in obj.values():
+                refs.extend(_refs(value))
+        elif isinstance(obj, list):
+            for item in obj:
+                refs.extend(_refs(item))
+        return refs
+
+    refs = sorted(set(_refs(profile.raw)))
+    migrated = migrate_legacy_keyring(refs)
+    if migrated:
+        for ref in migrated:
+            console.print(f"[green]Migriert:[/] {ref}")
+    else:
+        console.print("[dim]Nichts zu migrieren[/]")
+    missing = [r for r in refs if not has_secret(r)]
+    if missing:
+        console.print(f"[yellow]Fehlen noch:[/] {', '.join(missing)}")
+        console.print("[dim]Setzen: her secrets set REF[/]")
+
+
+def _pid_file(profile_name: str) -> Path:
+    return runtime_context(load_profile(profile_name)).state_dir / "daemon.pid"
+
+
+@daemon_app.command("run")
+def daemon_run(
+    ctx: typer.Context,
+) -> None:
+    """Daemon im Vordergrund (für systemd oder Debugging)."""
+    profile = ctx.obj.get("profile") if ctx.obj else None
+    pid_path = _pid_file(profile or load_profile(None).name)
+    pid_path.parent.mkdir(parents=True, exist_ok=True)
+    pid_path.write_text(str(os.getpid()), encoding="utf-8")
+    try:
+        run_daemon(profile)
+    finally:
+        pid_path.unlink(missing_ok=True)
+
+
+@daemon_app.command("status")
+def daemon_status(ctx: typer.Context) -> None:
+    """Daemon-Status für das Profil anzeigen."""
+    profile = ctx.obj.get("profile") if ctx.obj else None
+    profile_name = profile or load_profile(None).name
+    pid_path = _pid_file(profile_name)
+    if not pid_path.exists():
+        console.print(f"[dim]Daemon nicht aktiv ({profile_name})[/]")
+        return
+    pid = int(pid_path.read_text(encoding="utf-8").strip())
+    try:
+        os.kill(pid, 0)
+        console.print(f"[green]Läuft[/] PID {pid} (Profil {profile_name})")
+    except OSError:
+        console.print(f"[yellow]Stale PID[/] {pid_path}")
+        pid_path.unlink(missing_ok=True)
+
+
+@daemon_app.command("stop")
+def daemon_stop(ctx: typer.Context) -> None:
+    """Laufenden Daemon beenden."""
+    profile = ctx.obj.get("profile") if ctx.obj else None
+    profile_name = profile or load_profile(None).name
+    pid_path = _pid_file(profile_name)
+    if not pid_path.exists():
+        console.print("[dim]Daemon nicht aktiv[/]")
+        return
+    pid = int(pid_path.read_text(encoding="utf-8").strip())
+    os.kill(pid, signal.SIGTERM)
+    pid_path.unlink(missing_ok=True)
+    console.print(f"[green]Gestoppt[/] PID {pid}")
+
+
+@daemon_app.command("start")
+def daemon_start(ctx: typer.Context) -> None:
+    """Daemon im Hintergrund starten."""
+    profile = ctx.obj.get("profile") if ctx.obj else None
+    profile_name = profile or load_profile(None).name
+    pid_path = _pid_file(profile_name)
+    if pid_path.exists():
+        try:
+            pid = int(pid_path.read_text(encoding="utf-8").strip())
+            os.kill(pid, 0)
+            console.print(f"[yellow]Läuft bereits[/] PID {pid}")
+            return
+        except OSError:
+            pid_path.unlink(missing_ok=True)
+
+    cmd = [
+        sys.executable,
+        "-m",
+        "her_sync.cli",
+        "daemon",
+        "run",
+        "--profile",
+        profile_name,
+    ]
+    subprocess.Popen(
+        cmd,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    console.print(f"[green]Daemon gestartet[/] (Profil {profile_name})")
+    console.print("[dim]Für Autostart: systemd user unit her@{profile}[/]")
+
+
+@app.command("status")
+def status_cmd(ctx: typer.Context) -> None:
+    """Share-FS Status für das Profil."""
+    profile = ctx.obj.get("profile") if ctx.obj else None
+    prof = load_profile(profile)
+    ctx = runtime_context(prof)
+    layout = ShareLayout(ctx.share_root)
+
+    console.print(f"[bold]Profil:[/] {ctx.profile_name}")
+    console.print(f"[bold]Share:[/] {ctx.share_root}")
+
+    table = Table(title="Share-FS")
+    table.add_column("Pfad")
+    table.add_column("Status")
+    checks = [
+        (layout.cashflows_unassigned, "Unzugeordnete Buchungen"),
+        (layout.cashflows_history, "Kostenstellen-Muster"),
+        (layout.cost_centers, "Kostenstellen"),
+        (layout.open_invoices, "Offene Rechnungen"),
+        (layout.receipts, "Belege"),
+        (layout.extract_results, "Agent-Ergebnisse"),
+        (layout.calendar, "Kalender"),
+        (layout.emails, "E-Mails"),
+    ]
+    for path, label in checks:
+        if path.is_dir():
+            table.add_row(label, f"{len(list(path.iterdir()))} Einträge")
+        elif path.exists():
+            table.add_row(label, "vorhanden")
+        else:
+            table.add_row(label, "[dim]fehlt[/]")
+    console.print(table)
+
+
+if __name__ == "__main__":
+    app()

her_sync/cli_helpers.py

@@ -0,0 +1,10 @@
+"""Gemeinsame CLI-Hilfen für Typer-Gruppen."""
+
+from __future__ import annotations
+
+import typer
+
+
+def group_typer(*, help: str) -> typer.Typer:
+    """Typer-Gruppe — ohne Subbefehl automatisch Hilfe anzeigen."""
+    return typer.Typer(help=help, no_args_is_help=True)

her_sync/collectors/__init__.py

@@ -0,0 +1,10 @@
+from her_sync.collectors.cashflows import collect_cashflow_history, collect_cashflows
+from her_sync.collectors.invoices import collect_open_invoices
+from her_sync.collectors.receipts import collect_receipts
+
+__all__ = [
+    "collect_cashflow_history",
+    "collect_cashflows",
+    "collect_open_invoices",
+    "collect_receipts",
+]

her_sync/collectors/cashflows.py

@@ -0,0 +1,166 @@
+"""Cashflow-Daten aus BDE sammeln und ins Share-FS schreiben."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+
+from her_sync.bde.cashflows import CashflowService
+from her_sync.bde.cost_centers import load_cost_center_map
+from her_sync.bde.invoices import InvoiceService
+from her_sync.bde.session import BdeSession
+from her_sync.config import BdeSettings
+from her_sync.io.xlsx import read_rows, write_rows
+from her_sync.share.layout import ShareLayout
+from her_sync.share.schemas import CASHFLOWS_HISTORY_COLUMNS, CASHFLOWS_UNASSIGNED_COLUMNS
+
+
+@dataclass
+class CashflowCollectResult:
+    unassigned: int
+
+
+@dataclass
+class CashflowHistoryCollectResult:
+    history: int
+    cost_centers: int
+    skipped: bool = False
+
+
+def _load_unassigned_status(path) -> dict[int, dict[str, str]]:
+    if not path.exists():
+        return {}
+    return {
+        int(row["id"]): {
+            "apply_status": str(row.get("apply_status") or "pending"),
+            "notes": str(row.get("notes") or ""),
+        }
+        for row in read_rows(path)
+        if row.get("id") is not None
+    }
+
+
+def _unassigned_rows(cashflows, existing_status: dict[int, dict[str, str]]) -> list[dict]:
+    rows: list[dict] = []
+    for cf in cashflows:
+        prev = existing_status.get(cf.id, {})
+        rows.append(
+            {
+                "id": cf.id,
+                "valid_date": cf.valid_date,
+                "amount": cf.amount,
+                "reason": cf.reason,
+                "assigned_invoice_ids": cf.assigned_invoice_ids,
+                "splitted": cf.splitted,
+                "cash_payment": cf.cash_payment,
+                "apply_status": prev.get("apply_status", "pending"),
+                "notes": prev.get("notes", ""),
+            }
+        )
+    return rows
+
+
+def _history_rows(cashflows, invoice_service: InvoiceService) -> list[dict]:
+    creditor_cache: dict[int, str] = {}
+    rows: list[dict] = []
+
+    for cf in cashflows:
+        invoice_creditor = ""
+        if cf.assigned_invoice_ids:
+            inv_id = cf.assigned_invoice_ids[0]
+            if inv_id not in creditor_cache:
+                creditor_cache[inv_id] = invoice_service.fetch_creditor_name(inv_id)
+            invoice_creditor = creditor_cache[inv_id]
+
+        rows.append(
+            {
+                "id": cf.id,
+                "valid_date": cf.valid_date,
+                "amount": cf.amount,
+                "reason": cf.reason,
+                "cost_center_ident": cf.cost_center_ident,
+                "assigned_invoice_ids": cf.assigned_invoice_ids,
+                "invoice_creditor": invoice_creditor,
+                "splitted": cf.splitted,
+                "cash_payment": cf.cash_payment,
+            }
+        )
+
+    return rows
+
+
+def collect_cashflows(
+    settings: BdeSettings,
+    layout: ShareLayout,
+) -> CashflowCollectResult:
+    """Buchungen ohne Kostenstelle (schnell, type=no_cost_center)."""
+    layout.ensure()
+    existing_status = _load_unassigned_status(layout.cashflows_unassigned)
+
+    with BdeSession(
+        base_url=settings.bde_base_url,
+        basic_user=settings.bde_basic_auth_user,
+        basic_pass=settings.bde_basic_auth_pass,
+        login=settings.bde_login,
+        password=settings.bde_password,
+        cookie_file=settings.bde_cookie_file(),
+    ) as session:
+        session.ensure_logged_in()
+        service = CashflowService(session, settings.bde_company_id)
+        unassigned = service.fetch_no_cost_center()
+
+        write_rows(
+            layout.cashflows_unassigned,
+            CASHFLOWS_UNASSIGNED_COLUMNS,
+            _unassigned_rows(unassigned, existing_status),
+        )
+
+    return CashflowCollectResult(unassigned=len(unassigned))
+
+
+def collect_cashflow_history(
+    settings: BdeSettings,
+    layout: ShareLayout,
+    history_months: int = 6,
+    *,
+    skip_if_exists: bool = False,
+) -> CashflowHistoryCollectResult:
+    """Historische Buchungen für Kostenstellen-Muster (langsam: type=all).
+
+    ``history_months`` filtert nur client-seitig nach dem Download.
+    """
+    layout.ensure()
+
+    if skip_if_exists and layout.cashflows_history.exists():
+        return CashflowHistoryCollectResult(history=0, cost_centers=0, skipped=True)
+
+    with BdeSession(
+        base_url=settings.bde_base_url,
+        basic_user=settings.bde_basic_auth_user,
+        basic_pass=settings.bde_basic_auth_pass,
+        login=settings.bde_login,
+        password=settings.bde_password,
+        cookie_file=settings.bde_cookie_file(),
+    ) as session:
+        session.ensure_logged_in()
+        cashflow_service = CashflowService(session, settings.bde_company_id)
+        invoice_service = InvoiceService(session, settings.bde_company_id)
+
+        raw = cashflow_service.fetch_history(months=history_months)
+        history = CashflowService.filter_history_patterns(raw)
+        cost_center_map = load_cost_center_map(session, settings.bde_company_id)
+
+        write_rows(
+            layout.cashflows_history,
+            CASHFLOWS_HISTORY_COLUMNS,
+            _history_rows(history, invoice_service),
+        )
+        layout.cost_centers.write_text(
+            json.dumps(cost_center_map, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+
+    return CashflowHistoryCollectResult(
+        history=len(history),
+        cost_centers=len(cost_center_map),
+    )

her_sync/collectors/invoices.py

@@ -0,0 +1,70 @@
+"""Offene Rechnungen sammeln."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from her_sync.bde.invoices import InvoiceService
+from her_sync.bde.session import BdeSession
+from her_sync.config import BdeSettings
+from her_sync.io.xlsx import write_rows
+from her_sync.share.layout import ShareLayout
+from her_sync.share.schemas import OPEN_INVOICES_COLUMNS
+
+
+@dataclass
+class InvoiceCollectResult:
+    open_creditor: int
+    gaps: int
+    exported: int
+
+
+def collect_open_invoices(
+    settings: BdeSettings,
+    layout: ShareLayout,
+    *,
+    gaps_only: bool = False,
+) -> InvoiceCollectResult:
+    layout.ensure()
+
+    with BdeSession(
+        base_url=settings.bde_base_url,
+        basic_user=settings.bde_basic_auth_user,
+        basic_pass=settings.bde_basic_auth_pass,
+        login=settings.bde_login,
+        password=settings.bde_password,
+        cookie_file=settings.bde_cookie_file(),
+    ) as session:
+        session.ensure_logged_in()
+        service = InvoiceService(session, settings.bde_company_id)
+        open_creditor = service.fetch_all_open_creditor()
+        gaps = [inv for inv in open_creditor if service._has_gap(inv)]
+        invoices = gaps if gaps_only else open_creditor
+
+        write_rows(
+            layout.open_invoices,
+            OPEN_INVOICES_COLUMNS,
+            [
+                {
+                    "invoice_id": inv.id,
+                    "invoice_number": inv.invoice_number,
+                    "invoice_date": inv.invoice_date,
+                    "due_date": inv.due_date,
+                    "amount": inv.amount,
+                    "creditor_name": inv.creditor_name,
+                    "state": inv.state,
+                    "has_bookings": inv.has_bookings,
+                    "booking_ids": inv.booking_ids,
+                    "has_receipts": inv.has_receipts,
+                    "receipt_count": inv.receipt_count,
+                    "gap_type": service.gap_type(inv),
+                }
+                for inv in invoices
+            ],
+        )
+
+    return InvoiceCollectResult(
+        open_creditor=len(open_creditor),
+        gaps=len(gaps),
+        exported=len(invoices),
+    )

her_sync/collectors/receipts.py

@@ -0,0 +1,30 @@
+"""Belege aus konfiguriertem FS-Pfad ins Share-FS kopieren."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from her_sync.config import BdeSettings
+from her_sync.share.layout import ShareLayout
+
+RECEIPT_EXTENSIONS = {".pdf", ".png", ".jpg", ".jpeg", ".tif", ".tiff", ".heic"}
+
+
+def collect_receipts(settings: BdeSettings, layout: ShareLayout) -> int:
+    layout.ensure()
+    source = settings.receipts_source_path
+    if not source.exists():
+        raise FileNotFoundError(f"RECEIPTS_SOURCE_PATH nicht gefunden: {source}")
+
+    copied = 0
+    for src in sorted(source.rglob("*")):
+        if not src.is_file() or src.suffix.lower() not in RECEIPT_EXTENSIONS:
+            continue
+        dest = layout.receipts / src.name
+        if dest.exists() and dest.stat().st_size == src.stat().st_size:
+            continue
+        shutil.copy2(src, dest)
+        copied += 1
+
+    return copied