nextcloud-cli 0.1.0__py3-none-any.whl

nextcloud_cli/commands/tasks.py

@@ -0,0 +1,250 @@
+"""Tasks (VTODO) operations on a CalDAV task list."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+
+import click
+from icalendar import Calendar as ICal
+from icalendar import Todo
+
+from nextcloud_cli.client import caldav_principal
+from nextcloud_cli.config import load
+from nextcloud_cli.rendering import render_status, render_tasks
+from nextcloud_cli.utils import (
+    CONTEXT_SETTINGS,
+    fail,
+    json_option,
+    parse_datetime,
+    spinner,
+    verbose_option,
+)
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+def tasks() -> None:
+    """Manage tasks (VTODO) via CalDAV."""
+
+
+def _find_task_list(principal, name: str | None):
+    candidates = []
+    for cal in principal.calendars():
+        comps = []
+        try:
+            comps = list(cal.components or [])
+        except Exception:
+            pass
+        if "VTODO" in comps or name and cal.name == name:
+            candidates.append(cal)
+    if name:
+        for cal in candidates:
+            if cal.name == name:
+                return cal
+        fail(f"task list not found: {name}")
+    if not candidates:
+        fail("no task lists found on the server")
+    return candidates[0]
+
+
+def _vtodo_to_dict(component, list_name: str) -> dict:
+    return {
+        "uid": str(component.get("UID")),
+        "summary": str(component.get("SUMMARY", "")),
+        "due": component.decoded("DUE").isoformat() if component.get("DUE") else None,
+        "status": str(component.get("STATUS", "")),
+        "priority": int(component.get("PRIORITY", 0)) or None,
+        "list": list_name,
+    }
+
+
+@verbose_option
+@json_option
+@tasks.command("list")
+@click.option("--list", "list_name", default=None, help="Specific task list name.")
+@click.option("--include-completed", is_flag=True)
+def list_(list_name: str | None, include_completed: bool, json_output: bool) -> None:
+    """List tasks."""
+    cfg = load()
+    out: list[dict] = []
+    with spinner("Fetching tasks", json_output):
+        with caldav_principal(cfg) as principal:
+            cal = _find_task_list(principal, list_name)
+            for todo in cal.todos(include_completed=include_completed):
+                ical = ICal.from_ical(todo.data)
+                for component in ical.walk("VTODO"):
+                    out.append(_vtodo_to_dict(component, cal.name))
+    render_tasks(out, json_output)
+
+
+_TASK_SEARCH_FIELDS = {
+    "summary": ("summary",),
+    "description": ("description",),
+    "category": ("category",),
+    "all": ("summary", "description"),
+}
+
+
+@verbose_option
+@json_option
+@tasks.command()
+@click.option("--list", "list_name", default=None, help="Specific task list name.")
+@click.option("--query", required=True, help="Substring to match (case-insensitive, server-side).")
+@click.option(
+    "--in",
+    "field",
+    type=click.Choice(list(_TASK_SEARCH_FIELDS.keys())),
+    default="summary",
+    help="Which iCalendar property to search (default: summary).",
+)
+@click.option("--include-completed", is_flag=True)
+def search(list_name: str | None, query: str, field: str, include_completed: bool, json_output: bool) -> None:
+    """Server-side text search over tasks (CalDAV text-match)."""
+    cfg = load()
+    fields = _TASK_SEARCH_FIELDS[field]
+    seen: set[str] = set()
+    out: list[dict] = []
+    with spinner(f"Searching '{query}' in tasks", json_output):
+        with caldav_principal(cfg) as principal:
+            cal = _find_task_list(principal, list_name)
+            for f in fields:
+                kwargs = {f: query, "todo": True, "include_completed": include_completed}
+                for todo in cal.search(**kwargs):
+                    ical = ICal.from_ical(todo.data)
+                    for component in ical.walk("VTODO"):
+                        uid = str(component.get("UID"))
+                        if uid in seen:
+                            continue
+                        seen.add(uid)
+                        out.append(_vtodo_to_dict(component, cal.name))
+    render_tasks(out, json_output)
+
+
+@verbose_option
+@json_option
+@tasks.command()
+@click.option("--list", "list_name", default=None)
+@click.option("--summary", required=True)
+@click.option("--due", default=None, help="ISO 8601 due date.")
+@click.option("--priority", default=None, type=int, help="0 (none) - 9 (lowest); 1 highest.")
+@click.option("--description", default="")
+def create(
+    list_name: str | None,
+    summary: str,
+    due: str | None,
+    priority: int | None,
+    description: str,
+    json_output: bool,
+) -> None:
+    """Create a new task."""
+    cfg = load()
+    ical = ICal()
+    ical.add("prodid", "-//nextcloud-cli//EN")
+    ical.add("version", "2.0")
+    todo = Todo()
+    uid = str(uuid.uuid4())
+    todo.add("uid", uid)
+    todo.add("summary", summary)
+    todo.add("status", "NEEDS-ACTION")
+    if due:
+        todo.add("due", parse_datetime(due, cfg.timezone))
+    if priority is not None:
+        todo.add("priority", priority)
+    if description:
+        todo.add("description", description)
+    ical.add_component(todo)
+
+    with spinner(f"Creating task '{summary}'", json_output):
+        with caldav_principal(cfg) as principal:
+            cal = _find_task_list(principal, list_name)
+            cal.save_todo(ical.to_ical().decode())
+    render_status("task created", json_output, uid=uid, summary=summary)
+
+
+@verbose_option
+@json_option
+@tasks.command()
+@click.option("--list", "list_name", default=None)
+@click.option("--uid", required=True)
+def complete(list_name: str | None, uid: str, json_output: bool) -> None:
+    """Mark a task as completed."""
+    cfg = load()
+    with spinner(f"Completing task {uid}", json_output):
+        with caldav_principal(cfg) as principal:
+            cal = _find_task_list(principal, list_name)
+            try:
+                todo = cal.todo_by_uid(uid)
+            except Exception:
+                fail(f"task not found: {uid}")
+            ical = ICal.from_ical(todo.data)
+            for component in ical.walk("VTODO"):
+                component["STATUS"] = "COMPLETED"
+                component["COMPLETED"] = datetime.utcnow()
+                component["PERCENT-COMPLETE"] = 100
+            todo.data = ical.to_ical().decode()
+            todo.save()
+    render_status("task completed", json_output, uid=uid)
+
+
+@verbose_option
+@json_option
+@tasks.command()
+@click.option("--list", "list_name", default=None)
+@click.option("--uid", required=True)
+@click.option("--summary", default=None)
+@click.option("--due", default=None)
+@click.option("--priority", default=None, type=int)
+@click.option("--description", default=None)
+def edit(
+    list_name: str | None,
+    uid: str,
+    summary: str | None,
+    due: str | None,
+    priority: int | None,
+    description: str | None,
+    json_output: bool,
+) -> None:
+    """Update fields of an existing task."""
+    cfg = load()
+    with spinner(f"Updating task {uid}", json_output):
+        with caldav_principal(cfg) as principal:
+            cal = _find_task_list(principal, list_name)
+            try:
+                todo = cal.todo_by_uid(uid)
+            except Exception:
+                fail(f"task not found: {uid}")
+            ical = ICal.from_ical(todo.data)
+            for component in ical.walk("VTODO"):
+                if summary is not None:
+                    component["SUMMARY"] = summary
+                if due is not None:
+                    if "DUE" in component:
+                        component["DUE"].dt = parse_datetime(due, cfg.timezone)
+                    else:
+                        component.add("due", parse_datetime(due, cfg.timezone))
+                if priority is not None:
+                    component["PRIORITY"] = priority
+                if description is not None:
+                    component["DESCRIPTION"] = description
+            todo.data = ical.to_ical().decode()
+            todo.save()
+    render_status("task updated", json_output, uid=uid)
+
+
+@verbose_option
+@json_option
+@tasks.command()
+@click.option("--list", "list_name", default=None)
+@click.option("--uid", required=True)
+def delete(list_name: str | None, uid: str, json_output: bool) -> None:
+    """Delete a task."""
+    cfg = load()
+    with spinner(f"Deleting task {uid}", json_output):
+        with caldav_principal(cfg) as principal:
+            cal = _find_task_list(principal, list_name)
+            try:
+                todo = cal.todo_by_uid(uid)
+            except Exception:
+                fail(f"task not found: {uid}")
+            todo.delete()
+    render_status("deleted", json_output, uid=uid)

nextcloud_cli/config.py

@@ -0,0 +1,151 @@
+"""Credential and configuration storage.
+
+Credentials (app password) are stored in the OS keyring when available, with a
+chmod 0600 JSON file fallback for systems without a keyring backend.
+
+Non-secret config (URL, username, timezone) lives in
+``~/.config/nextcloud-cli/config.json``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+import keyring
+from keyring.errors import KeyringError
+
+KEYRING_SERVICE = "nextcloud-cli"
+CONFIG_DIR = Path(os.environ.get("NEXTCLOUD_CLI_HOME", Path.home() / ".config" / "nextcloud-cli"))
+CONFIG_FILE = CONFIG_DIR / "config.json"
+SECRETS_FALLBACK_FILE = CONFIG_DIR / "secrets.json"
+
+
+@dataclass
+class Config:
+    url: str
+    username: str
+    password: str
+    timezone: str = "UTC"
+
+    @property
+    def webdav_files_url(self) -> str:
+        return f"{self.url.rstrip('/')}/remote.php/dav/files/{self.username}"
+
+    @property
+    def caldav_url(self) -> str:
+        return f"{self.url.rstrip('/')}/remote.php/dav"
+
+    @property
+    def carddav_principal(self) -> str:
+        return f"{self.url.rstrip('/')}/remote.php/dav/addressbooks/users/{self.username}/"
+
+    @property
+    def notes_api_url(self) -> str:
+        return f"{self.url.rstrip('/')}/index.php/apps/notes/api/v1/notes"
+
+
+def _ensure_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        os.chmod(CONFIG_DIR, stat.S_IRWXU)
+    except OSError:
+        pass
+
+
+def _write_secure(path: Path, data: dict) -> None:
+    _ensure_dir()
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2))
+    os.chmod(tmp, stat.S_IRUSR | stat.S_IWUSR)
+    tmp.replace(path)
+
+
+def _read_json(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def save(url: str, username: str, password: str, timezone: str = "UTC") -> None:
+    """Persist credentials and configuration."""
+    _ensure_dir()
+    _write_secure(CONFIG_FILE, {"url": url, "username": username, "timezone": timezone})
+
+    account = f"{username}@{url}"
+    try:
+        keyring.set_password(KEYRING_SERVICE, account, password)
+        if SECRETS_FALLBACK_FILE.exists():
+            SECRETS_FALLBACK_FILE.unlink()
+    except KeyringError:
+        _write_secure(SECRETS_FALLBACK_FILE, {account: password})
+
+
+def _load_password(username: str, url: str) -> str | None:
+    account = f"{username}@{url}"
+    try:
+        pwd = keyring.get_password(KEYRING_SERVICE, account)
+        if pwd:
+            return pwd
+    except KeyringError:
+        pass
+    fallback = _read_json(SECRETS_FALLBACK_FILE)
+    return fallback.get(account)
+
+
+def load() -> Config:
+    """Load full configuration. Falls back to environment variables when
+    no on-disk config is present, matching the original hermes-nextcloud
+    contract (``NEXTCLOUD_URL`` / ``NEXTCLOUD_USER`` / ``NEXTCLOUD_TOKEN``).
+    """
+    cfg = _read_json(CONFIG_FILE)
+    url = cfg.get("url") or os.environ.get("NEXTCLOUD_URL")
+    username = cfg.get("username") or os.environ.get("NEXTCLOUD_USER")
+    timezone = cfg.get("timezone") or os.environ.get("NEXTCLOUD_TIMEZONE", "UTC")
+
+    if not url or not username:
+        raise ConfigError(
+            "not logged in — run `nxcloud login` "
+            "or set NEXTCLOUD_URL / NEXTCLOUD_USER / NEXTCLOUD_TOKEN"
+        )
+
+    password = os.environ.get("NEXTCLOUD_TOKEN") or _load_password(username, url)
+    if not password:
+        raise ConfigError(
+            "no app password available — re-run `nxcloud login` or set NEXTCLOUD_TOKEN"
+        )
+
+    return Config(url=url, username=username, password=password, timezone=timezone)
+
+
+def clear() -> None:
+    """Remove stored credentials and configuration."""
+    cfg = _read_json(CONFIG_FILE)
+    username = cfg.get("username")
+    url = cfg.get("url")
+    if username and url:
+        try:
+            keyring.delete_password(KEYRING_SERVICE, f"{username}@{url}")
+        except KeyringError:
+            pass
+    for path in (CONFIG_FILE, SECRETS_FALLBACK_FILE):
+        if path.exists():
+            path.unlink()
+
+
+class ConfigError(click.ClickException):
+    """Raised when configuration is missing or invalid.
+
+    Inheriting from :class:`click.ClickException` lets the CLI print a clean
+    one-line error and exit with status 1 instead of a Python traceback.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

nextcloud_cli/rendering.py

@@ -0,0 +1,262 @@
+"""Rich renderers for human-friendly CLI output.
+
+Every renderer accepts ``json_output``: when True, the function delegates to
+``emit`` so the legacy machine-readable format is preserved untouched.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from rich.box import ROUNDED, SIMPLE_HEAD
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from nextcloud_cli.utils import console, emit
+
+
+def _format_epoch(value: Any) -> str:
+    """Render a Unix epoch (int/str/float) as 'YYYY-MM-DD HH:MM' local time."""
+    if value in (None, "", 0):
+        return ""
+    try:
+        ts = int(value)
+    except (TypeError, ValueError):
+        return str(value)
+    try:
+        return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M")
+    except (OverflowError, OSError, ValueError):
+        return str(value)
+
+
+def _truncate(value: str, limit: int = 60) -> str:
+    if value is None:
+        return ""
+    value = str(value).replace("\n", " ").strip()
+    return value if len(value) <= limit else value[: limit - 1] + "…"
+
+
+def render_status(message: str, json_output: bool, **fields: Any) -> None:
+    """Success/result line. JSON mode emits a {status, ...} object."""
+    if json_output:
+        emit({"status": message, **fields})
+        return
+    body = Text(message, style="bold green")
+    if fields:
+        body.append("\n")
+        for k, v in fields.items():
+            body.append(f"\n  {k}: ", style="dim")
+            body.append(str(v), style="white")
+    console.print(Panel(body, border_style="green", box=ROUNDED, expand=False))
+
+
+def render_files_list(items: list[dict], path: str, json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(
+        title=f"[bold]{path}[/bold]",
+        box=SIMPLE_HEAD,
+        header_style="bold magenta",
+        title_justify="left",
+    )
+    table.add_column("", width=2)
+    table.add_column("Name", style="cyan", no_wrap=True)
+    table.add_column("Size", justify="right", style="green")
+    table.add_column("Modified", style="dim")
+    for entry in items:
+        icon = "📁" if entry.get("type") == "directory" else "📄"
+        size = "—" if entry.get("type") == "directory" else entry.get("size_human") or "0 B"
+        table.add_row(icon, entry["name"], size, entry.get("modified") or "")
+    console.print(table)
+    console.print(f"[dim]{len(items)} item(s)[/dim]")
+
+
+def render_notes_list(items: list[dict], json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta", title="📝 Notes", title_justify="left")
+    table.add_column("ID", justify="right", style="dim")
+    table.add_column("Title", style="cyan")
+    table.add_column("Category", style="yellow")
+    table.add_column("Modified", style="dim")
+    for n in items:
+        table.add_row(
+            str(n.get("id", "")),
+            _truncate(n.get("title") or "(untitled)", 50),
+            n.get("category") or "—",
+            _format_epoch(n.get("modified")),
+        )
+    console.print(table)
+    console.print(f"[dim]{len(items)} note(s)[/dim]")
+
+
+def render_note(note: dict, json_output: bool) -> None:
+    if json_output:
+        emit(note)
+        return
+    title = note.get("title") or "(untitled)"
+    category = note.get("category") or ""
+    header = f"[bold cyan]{title}[/bold cyan]"
+    if category:
+        header += f"  [yellow]·[/yellow] [yellow]{category}[/yellow]"
+    body = note.get("content", "") or "[dim](empty)[/dim]"
+    console.print(Panel(body, title=header, border_style="cyan", box=ROUNDED))
+
+
+def render_calendars(items: list[dict], json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta", title="📅 Calendars", title_justify="left")
+    table.add_column("Name", style="cyan")
+    table.add_column("URL", style="dim")
+    for c in items:
+        table.add_row(c["name"], c.get("url", ""))
+    console.print(table)
+    console.print(f"[dim]{len(items)} calendar(s)[/dim]")
+
+
+def render_events(items: list[dict], json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta", title="📆 Events", title_justify="left")
+    table.add_column("Start", style="green")
+    table.add_column("End", style="dim")
+    table.add_column("Summary", style="cyan")
+    table.add_column("Location", style="yellow")
+    table.add_column("Attendees", justify="right", style="magenta")
+    for e in items:
+        table.add_row(
+            e.get("start") or "",
+            e.get("end") or "",
+            _truncate(e.get("summary") or "", 50),
+            _truncate(e.get("location") or "", 25),
+            str(len(e.get("attendees") or [])),
+        )
+    console.print(table)
+    console.print(f"[dim]{len(items)} event(s)[/dim]")
+
+
+_TASK_STATUS_STYLE = {
+    "COMPLETED": ("✓", "green"),
+    "NEEDS-ACTION": ("○", "yellow"),
+    "IN-PROCESS": ("◐", "cyan"),
+    "CANCELLED": ("✗", "red"),
+}
+
+
+def render_tasks(items: list[dict], json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta", title="✅ Tasks", title_justify="left")
+    table.add_column("", width=1)
+    table.add_column("Summary", style="cyan")
+    table.add_column("Due", style="green")
+    table.add_column("Priority", justify="right")
+    table.add_column("List", style="dim")
+    for t in items:
+        status = (t.get("status") or "").upper()
+        glyph, style = _TASK_STATUS_STYLE.get(status, ("·", "white"))
+        prio = t.get("priority")
+        prio_str = str(prio) if prio else "—"
+        summary = _truncate(t.get("summary") or "", 50)
+        if status == "COMPLETED":
+            summary = f"[strike dim]{summary}[/strike dim]"
+        table.add_row(f"[{style}]{glyph}[/{style}]", summary, t.get("due") or "—", prio_str, t.get("list") or "")
+    console.print(table)
+    console.print(f"[dim]{len(items)} task(s)[/dim]")
+
+
+def render_addressbooks(items: list[dict], json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta", title="📇 Address books", title_justify="left")
+    table.add_column("Name", style="cyan")
+    table.add_column("Display name", style="white")
+    table.add_column("Href", style="dim")
+    for b in items:
+        table.add_row(b["name"], b.get("displayname", ""), b.get("href", ""))
+    console.print(table)
+    console.print(f"[dim]{len(items)} address book(s)[/dim]")
+
+
+def render_contacts(items: list[dict], json_output: bool) -> None:
+    if json_output:
+        emit(items)
+        return
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta", title="👥 Contacts", title_justify="left")
+    table.add_column("Name", style="cyan")
+    table.add_column("Emails", style="green")
+    table.add_column("Phones", style="yellow")
+    table.add_column("UID", style="dim")
+    for c in items:
+        emails = ", ".join(c.get("emails") or []) or "—"
+        phones = ", ".join(c.get("phones") or []) or "—"
+        table.add_row(c.get("fn") or "(no name)", _truncate(emails, 40), _truncate(phones, 30), _truncate(c.get("uid") or "", 20))
+    console.print(table)
+    console.print(f"[dim]{len(items)} contact(s)[/dim]")
+
+
+def render_contact(card: dict, json_output: bool) -> None:
+    if json_output:
+        emit(card)
+        return
+    body = Text()
+    body.append(card.get("fn") or "(no name)", style="bold cyan")
+    body.append("\n\n")
+    body.append("Emails:\n", style="bold")
+    for e in card.get("emails") or []:
+        body.append(f"  • {e}\n", style="green")
+    if not card.get("emails"):
+        body.append("  —\n", style="dim")
+    body.append("\nPhones:\n", style="bold")
+    for p in card.get("phones") or []:
+        body.append(f"  • {p}\n", style="yellow")
+    if not card.get("phones"):
+        body.append("  —\n", style="dim")
+    body.append("\nUID: ", style="dim")
+    body.append(card.get("uid") or "—", style="dim")
+    console.print(Panel(body, border_style="cyan", box=ROUNDED, expand=False))
+
+
+def render_check(results: dict, json_output: bool) -> None:
+    if json_output:
+        emit(results)
+        return
+    header = Text()
+    header.append("URL: ", style="bold")
+    header.append(f"{results['url']}\n")
+    header.append("User: ", style="bold")
+    header.append(f"{results['username']}\n")
+    header.append("Timezone: ", style="bold")
+    header.append(f"{results['timezone']}")
+    console.print(Panel(header, title="🔌 Connectivity check", border_style="cyan", box=ROUNDED, expand=False))
+
+    table = Table(box=SIMPLE_HEAD, header_style="bold magenta")
+    table.add_column("Endpoint", style="cyan")
+    table.add_column("Method", style="dim")
+    table.add_column("Status", justify="right")
+    table.add_column("Time", justify="right", style="green")
+    table.add_column("URL", style="dim")
+    all_ok = True
+    for label, info in results["endpoints"].items():
+        ok = info.get("ok")
+        if not ok:
+            all_ok = False
+        if ok:
+            status_cell = f"[green]✓ {info.get('status')}[/green]"
+        else:
+            status_cell = f"[red]✗ {info.get('status') or info.get('error_type', 'ERR')}[/red]"
+        table.add_row(label, info["method"], status_cell, f"{info['elapsed_ms']} ms", info["url"])
+    console.print(table)
+    if all_ok:
+        console.print("[bold green]✓ all endpoints reachable[/bold green]")
+    else:
+        console.print("[bold red]✗ some endpoints failed[/bold red]")