nextcloud-cli 0.1.0__py3-none-any.whl

nextcloud_cli/commands/contacts.py

@@ -0,0 +1,266 @@
+"""Contacts (CardDAV) operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from xml.etree import ElementTree as ET
+from xml.sax.saxutils import escape as xml_escape
+
+import click
+import vobject
+
+from nextcloud_cli.client import http_client
+from nextcloud_cli.config import Config, load
+from nextcloud_cli.rendering import (
+    render_addressbooks,
+    render_contact,
+    render_contacts,
+    render_status,
+)
+from nextcloud_cli.utils import CONTEXT_SETTINGS, fail, json_option, spinner, verbose_option
+
+CARDDAV_NS = {"d": "DAV:", "card": "urn:ietf:params:xml:ns:carddav"}
+
+PROPFIND_ADDRESSBOOKS = """<?xml version="1.0" encoding="utf-8"?>
+<d:propfind xmlns:d="DAV:" xmlns:card="urn:ietf:params:xml:ns:carddav">
+  <d:prop>
+    <d:displayname/>
+    <d:resourcetype/>
+  </d:prop>
+</d:propfind>"""
+
+REPORT_ADDRESSBOOK_QUERY = """<?xml version="1.0" encoding="utf-8"?>
+<card:addressbook-query xmlns:d="DAV:" xmlns:card="urn:ietf:params:xml:ns:carddav">
+  <d:prop>
+    <d:getetag/>
+    <card:address-data/>
+  </d:prop>
+</card:addressbook-query>"""
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+def contacts() -> None:
+    """Manage contacts via CardDAV."""
+
+
+def _abook_url(cfg: Config, name: str) -> str:
+    return f"{cfg.carddav_principal.rstrip('/')}/{name}/"
+
+
+def _vcard_to_dict(card: vobject.base.Component) -> dict:
+    fn = getattr(card, "fn", None)
+    emails = [e.value for e in card.contents.get("email", [])]
+    tels = [t.value for t in card.contents.get("tel", [])]
+    return {
+        "uid": getattr(card, "uid", None).value if hasattr(card, "uid") else None,
+        "fn": fn.value if fn else None,
+        "emails": emails,
+        "phones": tels,
+    }
+
+
+@verbose_option
+@json_option
+@contacts.command("list")
+def list_addressbooks(json_output: bool) -> None:
+    """List address books."""
+    cfg = load()
+    with spinner("Fetching address books", json_output):
+        with http_client(cfg, accept="application/xml") as http:
+            response = http.request(
+                "PROPFIND",
+                cfg.carddav_principal,
+                content=PROPFIND_ADDRESSBOOKS,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+            )
+    if response.status_code >= 400:
+        fail(f"PROPFIND failed: {response.status_code}")
+
+    root = ET.fromstring(response.text)
+    books = []
+    for resp in root.findall("d:response", CARDDAV_NS):
+        href = resp.findtext("d:href", "", CARDDAV_NS)
+        if href.rstrip("/") == cfg.carddav_principal.rstrip("/").split(cfg.url, 1)[-1].rstrip("/"):
+            continue
+        display = resp.findtext(".//d:displayname", "", CARDDAV_NS)
+        if display:
+            books.append({"name": Path(href.rstrip("/")).name, "displayname": display, "href": href})
+    render_addressbooks(books, json_output)
+
+
+_PROP_FIELDS = {
+    "name": ("FN",),
+    "email": ("EMAIL",),
+    "phone": ("TEL",),
+    "all": ("FN", "EMAIL", "TEL"),
+}
+
+
+def _build_search_report(query: str, fields: tuple[str, ...]) -> str:
+    """Build a CardDAV addressbook-query REPORT body with text-match filters."""
+    safe = xml_escape(query)
+    filters = "\n".join(
+        f'    <card:prop-filter name="{f}">'
+        f'      <card:text-match collation="i;unicode-casemap" match-type="contains">{safe}</card:text-match>'
+        f'    </card:prop-filter>'
+        for f in fields
+    )
+    return f"""<?xml version="1.0" encoding="utf-8"?>
+<card:addressbook-query xmlns:d="DAV:" xmlns:card="urn:ietf:params:xml:ns:carddav">
+  <d:prop>
+    <d:getetag/>
+    <card:address-data/>
+  </d:prop>
+  <card:filter test="anyof">
+{filters}
+  </card:filter>
+</card:addressbook-query>"""
+
+
+@verbose_option
+@json_option
+@contacts.command()
+@click.option("--addressbook", required=True)
+@click.option("--query", required=True, help="Substring to match (case-insensitive).")
+@click.option(
+    "--in",
+    "field",
+    type=click.Choice(list(_PROP_FIELDS.keys())),
+    default="all",
+    help="Which vCard property to search (default: all).",
+)
+def search(addressbook: str, query: str, field: str, json_output: bool) -> None:
+    """Server-side search across contacts in an address book (CardDAV text-match)."""
+    cfg = load()
+    body = _build_search_report(query, _PROP_FIELDS[field])
+    with spinner(f"Searching '{query}' in {addressbook}", json_output):
+        with http_client(cfg, accept="application/xml") as http:
+            response = http.request(
+                "REPORT",
+                _abook_url(cfg, addressbook),
+                content=body,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+            )
+    if response.status_code >= 400:
+        fail(f"REPORT failed: {response.status_code}: {response.text}")
+
+    root = ET.fromstring(response.text)
+    out = []
+    for resp in root.findall("d:response", CARDDAV_NS):
+        href = resp.findtext("d:href", "", CARDDAV_NS)
+        data = resp.findtext(".//card:address-data", "", CARDDAV_NS)
+        if not data:
+            continue
+        try:
+            card = vobject.readOne(data)
+        except Exception:
+            continue
+        item = _vcard_to_dict(card)
+        item["href"] = href
+        out.append(item)
+    render_contacts(out, json_output)
+
+
+@verbose_option
+@json_option
+@contacts.command()
+@click.option("--addressbook", required=True)
+def cards(addressbook: str, json_output: bool) -> None:
+    """List contacts in an address book."""
+    cfg = load()
+    with spinner(f"Fetching contacts from {addressbook}", json_output):
+        with http_client(cfg, accept="application/xml") as http:
+            response = http.request(
+                "REPORT",
+                _abook_url(cfg, addressbook),
+                content=REPORT_ADDRESSBOOK_QUERY,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+            )
+    if response.status_code >= 400:
+        fail(f"REPORT failed: {response.status_code}")
+
+    root = ET.fromstring(response.text)
+    out = []
+    for resp in root.findall("d:response", CARDDAV_NS):
+        href = resp.findtext("d:href", "", CARDDAV_NS)
+        data = resp.findtext(".//card:address-data", "", CARDDAV_NS)
+        if not data:
+            continue
+        try:
+            card = vobject.readOne(data)
+        except Exception:
+            continue
+        item = _vcard_to_dict(card)
+        item["href"] = href
+        out.append(item)
+    render_contacts(out, json_output)
+
+
+@verbose_option
+@json_option
+@contacts.command()
+@click.option("--addressbook", required=True)
+@click.option("--uid", required=True)
+def get(addressbook: str, uid: str, json_output: bool) -> None:
+    """Fetch a single contact by UID."""
+    cfg = load()
+    with spinner(f"Fetching contact {uid}", json_output):
+        with http_client(cfg, accept="application/xml") as http:
+            response = http.request(
+                "REPORT",
+                _abook_url(cfg, addressbook),
+                content=REPORT_ADDRESSBOOK_QUERY,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+            )
+    if response.status_code >= 400:
+        fail(f"REPORT failed: {response.status_code}")
+
+    root = ET.fromstring(response.text)
+    for resp in root.findall("d:response", CARDDAV_NS):
+        data = resp.findtext(".//card:address-data", "", CARDDAV_NS)
+        if not data:
+            continue
+        try:
+            card = vobject.readOne(data)
+        except Exception:
+            continue
+        if hasattr(card, "uid") and card.uid.value == uid:
+            render_contact(_vcard_to_dict(card), json_output)
+            return
+    fail(f"contact not found: {uid}")
+
+
+@verbose_option
+@json_option
+@contacts.command()
+@click.option("--addressbook", required=True)
+@click.option("--uid", required=True)
+@click.option("--local", "local", required=True, type=click.Path(dir_okay=False))
+def export(addressbook: str, uid: str, local: str, json_output: bool) -> None:
+    """Export a contact as a vCard file."""
+    cfg = load()
+    with spinner(f"Exporting contact {uid}", json_output):
+        with http_client(cfg, accept="application/xml") as http:
+            response = http.request(
+                "REPORT",
+                _abook_url(cfg, addressbook),
+                content=REPORT_ADDRESSBOOK_QUERY,
+                headers={"Depth": "1", "Content-Type": "application/xml"},
+            )
+    if response.status_code >= 400:
+        fail(f"REPORT failed: {response.status_code}")
+
+    root = ET.fromstring(response.text)
+    for resp in root.findall("d:response", CARDDAV_NS):
+        data = resp.findtext(".//card:address-data", "", CARDDAV_NS)
+        if not data:
+            continue
+        try:
+            card = vobject.readOne(data)
+        except Exception:
+            continue
+        if hasattr(card, "uid") and card.uid.value == uid:
+            Path(local).write_text(card.serialize())
+            render_status("exported", json_output, uid=uid, path=local)
+            return
+    fail(f"contact not found: {uid}")

nextcloud_cli/commands/files.py

@@ -0,0 +1,166 @@
+"""File operations against the user's Nextcloud WebDAV root."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import click
+from webdav4.client import ResourceAlreadyExists, ResourceNotFound
+
+from nextcloud_cli.client import http_client, webdav_client
+from nextcloud_cli.config import load
+from nextcloud_cli.rendering import render_files_list, render_status
+from nextcloud_cli.utils import (
+    CONTEXT_SETTINGS,
+    fail,
+    format_size,
+    json_option,
+    spinner,
+    verbose_option,
+)
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+def files() -> None:
+    """Manage files via WebDAV."""
+
+
+@verbose_option
+@json_option
+@files.command("list")
+@click.option("--path", default="/", help="Remote directory path.")
+def list_(path: str, json_output: bool) -> None:
+    """List files in a remote directory."""
+    cfg = load()
+    client = webdav_client(cfg)
+    try:
+        with spinner(f"Listing {path}", json_output):
+            entries = client.ls(path, detail=True)
+    except ResourceNotFound:
+        fail(f"path not found: {path}")
+    items = [
+        {
+            "name": Path(entry["name"]).name or entry["name"],
+            "path": entry["name"],
+            "type": entry["type"],
+            "size": entry.get("content_length") or 0,
+            "size_human": format_size(entry.get("content_length") or 0),
+            "modified": str(entry.get("modified")) if entry.get("modified") else None,
+        }
+        for entry in entries
+    ]
+    render_files_list(items, path, json_output)
+
+
+@verbose_option
+@json_option
+@files.command()
+@click.option("--local", "local", required=True, type=click.Path(exists=True, dir_okay=False))
+@click.option("--remote", required=True, help="Destination path on the server.")
+def upload(local: str, remote: str, json_output: bool) -> None:
+    """Upload a local file to the server."""
+    cfg = load()
+    client = webdav_client(cfg)
+    with spinner(f"Uploading {local} → {remote}", json_output):
+        client.upload_file(from_path=local, to_path=remote, overwrite=True)
+    render_status("uploaded", json_output, local=local, remote=remote)
+
+
+@verbose_option
+@json_option
+@files.command()
+@click.option("--remote", required=True, help="Source path on the server.")
+@click.option("--local", "local", required=True, type=click.Path(dir_okay=False))
+def download(remote: str, local: str, json_output: bool) -> None:
+    """Download a remote file to the local filesystem."""
+    cfg = load()
+    client = webdav_client(cfg)
+    try:
+        with spinner(f"Downloading {remote} → {local}", json_output):
+            client.download_file(from_path=remote, to_path=local)
+    except ResourceNotFound:
+        fail(f"remote file not found: {remote}")
+    render_status("downloaded", json_output, remote=remote, local=local)
+
+
+@verbose_option
+@json_option
+@files.command()
+@click.option("--path", required=True, help="Path to delete.")
+def delete(path: str, json_output: bool) -> None:
+    """Delete a remote file or directory."""
+    cfg = load()
+    client = webdav_client(cfg)
+    try:
+        with spinner(f"Deleting {path}", json_output):
+            client.remove(path)
+    except ResourceNotFound:
+        fail(f"path not found: {path}")
+    render_status("deleted", json_output, path=path)
+
+
+@verbose_option
+@json_option
+@files.command()
+@click.option("--src", required=True, help="Current remote path.")
+@click.option("--dst", required=True, help="New remote path.")
+def move(src: str, dst: str, json_output: bool) -> None:
+    """Move or rename a file."""
+    cfg = load()
+    client = webdav_client(cfg)
+    try:
+        with spinner(f"Moving {src} → {dst}", json_output):
+            client.move(src, dst)
+    except ResourceNotFound:
+        fail(f"source not found: {src}")
+    render_status("moved", json_output, src=src, dst=dst)
+
+
+@verbose_option
+@json_option
+@files.command()
+@click.option("--path", required=True, help="Directory to create.")
+def mkdir(path: str, json_output: bool) -> None:
+    """Create a remote directory."""
+    cfg = load()
+    client = webdav_client(cfg)
+    try:
+        with spinner(f"Creating {path}", json_output):
+            client.mkdir(path)
+    except ResourceAlreadyExists:
+        fail(f"already exists: {path}")
+    render_status("created", json_output, path=path)
+
+
+@verbose_option
+@json_option
+@files.command()
+@click.option("--query", required=True, help="Substring to match (server-side, OCS unified search).")
+@click.option("--limit", default=None, type=click.IntRange(min=1), help="Max number of matches.")
+def search(query: str, limit: int | None, json_output: bool) -> None:
+    """Server-side filename search via the OCS unified search API."""
+    cfg = load()
+    url = f"{cfg.url.rstrip('/')}/ocs/v2.php/search/providers/files/search"
+    params: dict[str, str | int] = {"term": query}
+    if limit is not None:
+        params["limit"] = limit
+    with spinner(f"Searching for '{query}'", json_output):
+        with http_client(cfg) as http:
+            response = http.get(url, params=params)
+    if response.status_code >= 400:
+        fail(f"search failed: {response.status_code}: {response.text}")
+    payload = response.json().get("ocs", {}).get("data", {})
+    entries = payload.get("entries", []) or []
+    matches = [
+        {
+            "name": entry.get("title"),
+            "path": entry.get("attributes", {}).get("path") or entry.get("subline") or "",
+            "resourceUrl": entry.get("resourceUrl"),
+            "fileId": entry.get("attributes", {}).get("fileId"),
+            "icon": entry.get("icon"),
+        }
+        for entry in entries
+    ]
+    if limit is not None:
+        matches = matches[:limit]
+    render_files_list(matches, f"matches for '{query}'", json_output)

nextcloud_cli/commands/notes.py

@@ -0,0 +1,119 @@
+"""Nextcloud Notes app — REST/JSON API."""
+
+from __future__ import annotations
+
+import click
+import httpx
+
+from nextcloud_cli.client import http_client
+from nextcloud_cli.config import load
+from nextcloud_cli.rendering import render_note, render_notes_list, render_status
+from nextcloud_cli.utils import CONTEXT_SETTINGS, fail, json_option, spinner, verbose_option
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+def notes() -> None:
+    """Manage notes (requires the Nextcloud Notes app)."""
+
+
+def _handle(response: httpx.Response) -> dict | list:
+    if response.status_code == 404:
+        fail("note not found")
+    if response.status_code == 401:
+        fail("unauthorized — check your app password")
+    if response.status_code >= 400:
+        fail(f"notes API error {response.status_code}: {response.text}")
+    return response.json() if response.content else {}
+
+
+@verbose_option
+@json_option
+@notes.command("list")
+@click.option("--category", default=None, help="Filter by category.")
+@click.option("--limit", default=None, type=click.IntRange(min=1), help="Max number of notes to fetch.")
+def list_(category: str | None, limit: int | None, json_output: bool) -> None:
+    """List all notes."""
+    cfg = load()
+    params: dict[str, str | int] = {}
+    if category is not None:
+        params["category"] = category
+    if limit is not None:
+        params["chunkSize"] = limit
+    with spinner("Fetching notes", json_output):
+        with http_client(cfg) as http:
+            data = _handle(http.get(cfg.notes_api_url, params=params or None))
+    notes_list = data if isinstance(data, list) else [data]
+    if limit is not None:
+        notes_list = notes_list[:limit]
+    render_notes_list(notes_list, json_output)
+
+
+@verbose_option
+@json_option
+@notes.command()
+@click.option("--id", "note_id", required=True, type=int)
+def get(note_id: int, json_output: bool) -> None:
+    """Fetch a single note by ID."""
+    cfg = load()
+    with spinner(f"Fetching note {note_id}", json_output):
+        with http_client(cfg) as http:
+            data = _handle(http.get(f"{cfg.notes_api_url}/{note_id}"))
+    render_note(data if isinstance(data, dict) else {}, json_output)
+
+
+@verbose_option
+@json_option
+@notes.command()
+@click.option("--title", required=True)
+@click.option("--content", default="", help="Body of the note.")
+@click.option("--category", default="", help="Category folder.")
+def create(title: str, content: str, category: str, json_output: bool) -> None:
+    """Create a new note."""
+    cfg = load()
+    payload = {"title": title, "content": content, "category": category}
+    with spinner(f"Creating note '{title}'", json_output):
+        with http_client(cfg) as http:
+            data = _handle(http.post(cfg.notes_api_url, json=payload))
+    if json_output:
+        from nextcloud_cli.utils import emit
+
+        emit(data)
+    else:
+        render_status("note created", json_output, id=data.get("id"), title=data.get("title"))
+
+
+@verbose_option
+@json_option
+@notes.command()
+@click.option("--id", "note_id", required=True, type=int)
+@click.option("--title", default=None)
+@click.option("--content", default=None)
+@click.option("--category", default=None)
+def edit(note_id: int, title: str | None, content: str | None, category: str | None, json_output: bool) -> None:
+    """Update an existing note. Only provided fields change."""
+    cfg = load()
+    payload = {k: v for k, v in {"title": title, "content": content, "category": category}.items() if v is not None}
+    if not payload:
+        fail("nothing to update — provide at least one of --title/--content/--category")
+    with spinner(f"Updating note {note_id}", json_output):
+        with http_client(cfg) as http:
+            data = _handle(http.put(f"{cfg.notes_api_url}/{note_id}", json=payload))
+    if json_output:
+        from nextcloud_cli.utils import emit
+
+        emit(data)
+    else:
+        render_status("note updated", json_output, id=note_id)
+
+
+@verbose_option
+@json_option
+@notes.command()
+@click.option("--id", "note_id", required=True, type=int)
+def delete(note_id: int, json_output: bool) -> None:
+    """Delete a note."""
+    cfg = load()
+    with spinner(f"Deleting note {note_id}", json_output):
+        with http_client(cfg) as http:
+            _handle(http.delete(f"{cfg.notes_api_url}/{note_id}"))
+    render_status("deleted", json_output, id=note_id)

nextcloud_cli/commands/setup.py

@@ -0,0 +1,66 @@
+"""Login / logout commands."""
+
+from __future__ import annotations
+
+import os
+
+import click
+import httpx
+
+from nextcloud_cli import config as cfg_module
+from nextcloud_cli.rendering import render_status
+from nextcloud_cli.utils import CONTEXT_SETTINGS, json_option, spinner, verbose_option
+
+
+def _resolve(flag_value: str | None, env_var: str, prompt: str, *, hidden: bool = False, default: str | None = None) -> str:
+    """flag value > env var > interactive prompt."""
+    if flag_value:
+        return flag_value
+    env_value = os.environ.get(env_var)
+    if env_value:
+        return env_value
+    return click.prompt(prompt, hide_input=hidden, default=default, type=str)
+
+
+@click.command(context_settings=CONTEXT_SETTINGS)
+@verbose_option
+@json_option
+@click.option("--url", default=None, help="Nextcloud server URL.")
+@click.option("--username", default=None, help="Nextcloud username.")
+@click.option("--password", default=None, help="App password (NOT your account password).")
+@click.option("--timezone", default=None, help="IANA timezone (e.g. Europe/Paris).")
+def login(url: str | None, username: str | None, password: str | None, timezone: str | None, json_output: bool) -> None:
+    """Log in to a Nextcloud server."""
+    url = _resolve(url, "NEXTCLOUD_URL", "Nextcloud URL").rstrip("/")
+    username = _resolve(username, "NEXTCLOUD_USER", "Username")
+    password = _resolve(password, "NEXTCLOUD_TOKEN", "App password", hidden=True)
+    timezone = _resolve(timezone, "NEXTCLOUD_TIMEZONE", "Timezone", default="UTC")
+
+    test_url = f"{url}/remote.php/dav/files/{username}/"
+    try:
+        with spinner(f"Authenticating to {url}", json_output):
+            response = httpx.request(
+                "PROPFIND",
+                test_url,
+                auth=(username, password),
+                headers={"Depth": "0"},
+                timeout=15.0,
+            )
+    except httpx.HTTPError as exc:
+        raise click.ClickException(f"could not reach server: {exc}") from exc
+    if response.status_code in (401, 403):
+        raise click.ClickException("authentication failed — check your username and app password")
+    if response.status_code >= 400:
+        raise click.ClickException(f"server returned HTTP {response.status_code}")
+
+    cfg_module.save(url=url, username=username, password=password, timezone=timezone)
+    render_status("logged-in", json_output, url=url, username=username, timezone=timezone)
+
+
+@click.command(context_settings=CONTEXT_SETTINGS)
+@verbose_option
+@json_option
+def logout(json_output: bool) -> None:
+    """Erase stored credentials."""
+    cfg_module.clear()
+    render_status("logged-out", json_output)