drp-dev 1.0.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,30 @@
+"""drp CLI — command-line tool for drp.
+
+Drop, share, and manage text snippets and files from the terminal.
+https://drp.fyi
+"""
+
+# VERSION file holds major.minor (e.g. "1.0") — only bumped manually.
+# CI queries PyPI for latest published version, bumps patch +1,
+# and seds this line to a literal before building: __version__ = '1.0.42'
+# Nothing committed back — merges between dev↔main stay clean.
+# Fallback: importlib.metadata for installed packages.
+
+def _resolve_version():
+    from pathlib import Path
+    vf = Path(__file__).resolve().parent.parent / 'VERSION'
+    if vf.is_file():
+        return vf.read_text().strip()
+    try:
+        from importlib.metadata import version
+        return version('drp-dev')
+    except Exception:
+        pass
+    try:
+        from importlib.metadata import version
+        return version('drp')
+    except Exception:
+        return '0.0.0'
+
+__version__ = '1.0.0'
+DEFAULT_HOST = 'https://drp.fyi'

cli/__main__.py

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

cli/api/__init__.py

@@ -0,0 +1,18 @@
+"""
+Public API surface for the drp CLI.
+Import from here to keep command modules clean.
+"""
+
+from .auth import get_csrf, login
+from .text import upload_text, get_clipboard
+from .file import upload_file, get_file, upload_from_url
+from .actions import delete, rename, renew, list_drops, key_exists, save_bookmark
+from .helpers import slug, err, ok
+
+__all__ = [
+    'get_csrf', 'login',
+    'upload_text', 'get_clipboard',
+    'upload_file', 'get_file', 'upload_from_url',
+    'delete', 'rename', 'renew', 'list_drops', 'key_exists', 'save_bookmark',
+    'slug', 'err', 'ok',
+]

cli/api/actions.py

@@ -0,0 +1,205 @@
+"""
+Drop action API calls: delete, rename, renew, list, key_exists, save_bookmark.
+
+URL conventions:
+  Clipboard:  /key/delete|rename|renew|save/
+  File:       /f/key/delete|rename|renew|save/
+
+Return value conventions for callers (manage.py):
+  rename() → new_key string   on success
+             False             on a known/reported error (404, 409, 403 …)
+             None              on an unexpected error (network, bad JSON, etc.)
+  delete() → True / False (unchanged)
+  renew()  → (expires_at, renewals) / (None, None) (unchanged)
+"""
+
+from .auth import get_csrf
+from .helpers import err
+
+
+def _url(host, ns, key, action):
+    if ns == 'f':
+        return f'{host}/f/{key}/{action}/'
+    return f'{host}/{key}/{action}/'
+
+
+def delete(host, session, key, ns='c'):
+    csrf = get_csrf(host, session)
+    try:
+        res = session.delete(
+            _url(host, ns, key, 'delete'),
+            headers={'X-CSRFToken': csrf},
+            timeout=10,
+        )
+        if res.ok:
+            return True
+        if res.status_code == 404:
+            err(f'Drop not found. If this is a file drop, use: drp rm -f {key}')
+            _report_http('rm', 404, f'delete ns={ns} — likely wrong namespace')
+            return False
+        _handle_error(res, 'Delete failed')
+        _report_http('rm', res.status_code, f'delete ns={ns}')
+    except Exception as e:
+        err(f'Delete error: {e}')
+    return False
+
+
+def rename(host, session, key, new_key, ns='c'):
+    """
+    Rename a drop key.
+
+    Returns:
+      str   — the new key on success
+      False — a known error that has already been printed and reported
+               (404 wrong-namespace, 409 key taken, 403 locked, 400 bad input)
+      None  — an unexpected error (network failure, unhandled status code)
+               caller should file a SilentFailure report
+    """
+    csrf = get_csrf(host, session)
+    try:
+        res = session.post(
+            _url(host, ns, key, 'rename'),
+            data={'new_key': new_key, 'csrfmiddlewaretoken': csrf},
+            timeout=10,
+        )
+        if res.ok:
+            return res.json().get('key')
+
+        # ── Known errors — print a helpful message and report, then return
+        # False so the caller knows not to file a redundant SilentFailure. ──
+        if res.status_code == 404:
+            ns_flag = '-f ' if ns == 'f' else ''
+            other_flag = '' if ns == 'f' else '-f '
+            err(
+                f'Drop /{ns_flag}{key}/ not found. '
+                f'If this is a {"file" if ns == "c" else "clipboard"} drop, '
+                f'use: drp mv {other_flag}{key} {new_key}'
+            )
+            _report_http('mv', 404, f'rename ns={ns} — likely wrong namespace')
+            return False
+
+        if res.status_code == 409:
+            err(f'Key "{new_key}" is already taken.')
+            _report_http('mv', 409, f'rename ns={ns} key conflict')
+            return False
+
+        if res.status_code == 403:
+            try:
+                msg = res.json().get('error', 'Permission denied.')
+            except Exception:
+                msg = 'Permission denied.'
+            err(f'Rename blocked: {msg}')
+            _report_http('mv', 403, f'rename ns={ns}')
+            return False
+
+        if res.status_code == 400:
+            _handle_error(res, 'Rename failed')
+            _report_http('mv', 400, f'rename ns={ns}')
+            return False
+
+        # Unexpected status — let caller decide whether to report
+        _handle_error(res, 'Rename failed')
+        _report_http('mv', res.status_code, f'rename ns={ns}')
+
+    except Exception as e:
+        err(f'Rename error: {e}')
+
+    return None
+
+
+def renew(host, session, key, ns='c'):
+    csrf = get_csrf(host, session)
+    try:
+        res = session.post(
+            _url(host, ns, key, 'renew'),
+            data={'csrfmiddlewaretoken': csrf},
+            timeout=10,
+        )
+        if res.ok:
+            data = res.json()
+            return data.get('expires_at'), data.get('renewals')
+        _handle_error(res, 'Renew failed')
+        _report_http('renew', res.status_code, f'renew ns={ns}')
+    except Exception as e:
+        err(f'Renew error: {e}')
+    return None, None
+
+
+def save_bookmark(host, session, key, ns='c'):
+    """
+    Bookmark a drop. Returns True if saved, False on failure.
+    Requires login — server returns 403 if not authenticated.
+    """
+    csrf = get_csrf(host, session)
+    try:
+        res = session.post(
+            _url(host, ns, key, 'save'),
+            data={'csrfmiddlewaretoken': csrf},
+            timeout=10,
+            allow_redirects=False,
+        )
+        if res.status_code in (301, 302, 303):
+            err('drp save requires a logged-in account. Run: drp login')
+            return False
+        if res.ok:
+            return True
+        if res.status_code == 403:
+            err('drp save requires a logged-in account. Run: drp login')
+            return False
+        if res.status_code == 404:
+            err(f'Drop /{key}/ not found.')
+            return False
+        _handle_error(res, 'Save failed')
+        _report_http('save', res.status_code, f'save_bookmark ns={ns}')
+    except Exception as e:
+        err(f'Save error: {e}')
+    return False
+
+
+def list_drops(host, session):
+    try:
+        res = session.get(
+            f'{host}/auth/account/',
+            headers={'Accept': 'application/json'},
+            timeout=15,
+        )
+        if res.ok:
+            return res.json().get('drops', [])
+        if res.status_code in (302, 403):
+            return None
+        err(f'Server returned {res.status_code}.')
+        _report_http('ls', res.status_code, 'list_drops')
+    except Exception as e:
+        err(f'List error: {e}')
+    return None
+
+
+def key_exists(host, session, key, ns='c'):
+    try:
+        res = session.get(
+            f'{host}/check-key/',
+            params={'key': key, 'ns': ns},
+            timeout=10,
+        )
+        if res.ok:
+            return not res.json().get('available', True)
+    except Exception:
+        pass
+    return False
+
+
+def _handle_error(res, prefix):
+    try:
+        msg = res.json().get('error', res.text[:200])
+    except Exception:
+        msg = res.text[:200]
+    err(f'{prefix}: {msg}')
+
+
+def _report_http(command: str, status_code: int, context: str) -> None:
+    """Fire-and-forget — never raises."""
+    try:
+        from cli.crash_reporter import report_http_error
+        report_http_error(command, status_code, context)
+    except Exception:
+        pass

cli/api/auth.py

@@ -0,0 +1,40 @@
+"""
+Authentication helpers: CSRF token fetching and login.
+"""
+
+from .helpers import err
+
+
+def get_csrf(host, session):
+    """Return csrftoken, fetching from server only if not already in session."""
+    token = _first_csrf(session)
+    if token:
+        return token
+    # Fetch the login page — guaranteed to set the csrftoken cookie
+    # (home page may not render {% csrf_token %} and won't set the cookie)
+    session.get(f'{host}/auth/login/', timeout=10)
+    return _first_csrf(session) or ''
+
+
+def _first_csrf(session):
+    """Safely get csrftoken even if duplicate cookies exist."""
+    for cookie in session.cookies:
+        if cookie.name == 'csrftoken':
+            return cookie.value
+    return None
+
+
+def login(host, session, identifier, password):
+    """
+    Authenticate with the drp server using username or email.
+    Returns True on success, False on bad credentials.
+    Raises requests.RequestException on network errors.
+    """
+    csrf = get_csrf(host, session)
+    res = session.post(
+        f'{host}/auth/login/',
+        data={'email': identifier, 'password': password, 'csrfmiddlewaretoken': csrf},
+        timeout=10,
+        allow_redirects=False,
+    )
+    return res.status_code in (301, 302)

cli/api/file.py

@@ -0,0 +1,340 @@
+"""
+File drop API calls.
+"""
+
+import os
+import mimetypes
+
+import requests as _requests
+
+from .auth import get_csrf
+from .helpers import err
+
+CHUNK = 256 * 1024
+
+
+def _report(command, msg):
+    try:
+        from cli.crash_reporter import report
+        report(command, RuntimeError(msg))
+    except Exception:
+        pass
+
+
+def _touch_session():
+    try:
+        from cli.session import SESSION_FILE
+        SESSION_FILE.touch()
+    except Exception:
+        pass
+
+
+# ── Upload ────────────────────────────────────────────────────────────────────
+
+def upload_file(host, session, filepath, key=None, expiry_days=None, password=None,
+                is_test=False, schedule=None, webhook_url=None, notify=None,
+                is_public=False, tags=None):
+    """
+    Upload a file using the prepare → direct-PUT → confirm flow.
+    Returns the drop key string on success, None on failure.
+    """
+    from cli.progress import ProgressBar
+
+    size         = os.path.getsize(filepath)
+    filename     = os.path.basename(filepath)
+    content_type = mimetypes.guess_type(filename)[0] or "application/octet-stream"
+
+    # ── Step 1: prepare ───────────────────────────────────────────────────────
+    payload = {
+        "filename":     filename,
+        "size":         size,
+        "content_type": content_type,
+        "ns":           "f",
+    }
+    if key:
+        payload["key"] = key
+    if expiry_days:
+        payload["expiry_days"] = expiry_days
+    if is_test:
+        payload["is_test"] = True
+
+    try:
+        csrf = get_csrf(host, session)
+        res  = session.post(
+            f"{host}/upload/prepare/",
+            json=payload,
+            headers={"X-CSRFToken": csrf},
+            timeout=30,
+        )
+        if not res.ok:
+            msg = f"Prepare failed (HTTP {res.status_code})"
+            _handle_error(res, "Prepare failed")
+            _report("up", msg)
+            return None
+        prep = res.json()
+        _touch_session()
+    except Exception as e:
+        err(f"Prepare error: {e}")
+        raise
+
+    presigned_url = prep["presigned_url"]
+    drop_key      = prep["key"]
+
+    # ── Step 2: stream file directly to B2 ───────────────────────────────────
+    bar = ProgressBar(size, label="uploading")
+
+    class _ProgressFile:
+        def __init__(self, path):
+            self._f = open(path, "rb")
+        def read(self, n=-1):
+            chunk = self._f.read(n)
+            if chunk:
+                bar.update(len(chunk))
+            return chunk
+        def __len__(self):
+            return size
+        def close(self):
+            self._f.close()
+
+    pf = _ProgressFile(filepath)
+    try:
+        put_res = _requests.put(
+            presigned_url,
+            data=pf,
+            headers={
+                "Content-Type":   content_type,
+                "Content-Length": str(size),
+            },
+            timeout=None,
+        )
+        if not put_res.ok:
+            msg = f"B2 upload failed (HTTP {put_res.status_code})"
+            err(f"{msg}: {put_res.text[:200]}")
+            _report("up", msg)
+            return None
+    except Exception as e:
+        err(f"Upload error: {e}")
+        raise
+    finally:
+        pf.close()
+
+    bar.done()
+
+    # ── Step 3: confirm ───────────────────────────────────────────────────────
+    confirm_payload = {
+        "key":          drop_key,
+        "ns":           "f",
+        "filename":     filename,
+        "content_type": content_type,
+    }
+    if expiry_days:
+        confirm_payload["expiry_days"] = expiry_days
+    if password:
+        confirm_payload["password"] = password
+    if is_test:
+        confirm_payload["is_test"] = True
+    if schedule:
+        confirm_payload["schedule"] = schedule
+    if webhook_url:
+        confirm_payload["webhook_url"] = webhook_url
+    if notify:
+        confirm_payload["notify"] = notify
+    if is_public:
+        confirm_payload["is_public"] = True
+    if tags:
+        confirm_payload["tags"] = tags
+
+    try:
+        csrf = get_csrf(host, session)
+        res  = session.post(
+            f"{host}/upload/confirm/",
+            json=confirm_payload,
+            headers={"X-CSRFToken": csrf},
+            timeout=30,
+        )
+        if res.ok:
+            _touch_session()
+            return res.json().get("key")
+        msg = f"Confirm failed (HTTP {res.status_code})"
+        _handle_error(res, "Confirm failed")
+        _report("up", msg)
+    except Exception as e:
+        err(f"Confirm error: {e}")
+        raise
+
+    return None
+
+
+# ── Download ──────────────────────────────────────────────────────────────────
+
+def get_file(host, session, key, password=''):
+    """
+    Fetch a file drop.
+
+    Returns:
+      ('file', (bytes_content, filename)) — success
+      ('password_required', None)         — password needed / wrong password
+      (None, None)                        — not found, expired, or error
+    """
+    from cli.progress import ProgressBar
+
+    headers = {"Accept": "application/json"}
+    if password:
+        headers["X-Drop-Password"] = password
+
+    try:
+        res = session.get(
+            f"{host}/f/{key}/",
+            headers=headers,
+            timeout=30,
+        )
+
+        if res.status_code == 401:
+            return 'password_required', None
+
+        if not res.ok:
+            _handle_http_error(res, key)
+            return None, None
+
+        _touch_session()
+
+        data = res.json()
+        if data.get("kind") != "file":
+            err(f"/f/{key}/ is not a file drop.")
+            return None, None
+
+        filename = data.get("filename", key)
+        filesize = data.get("filesize", 0)
+
+        b2_url = data.get("presigned_url")
+
+        if not b2_url:
+            download_path = data.get("download")
+            if not download_path:
+                err(f"No download URL in response for /f/{key}/.")
+                _report("get", "missing both presigned_url and download fields")
+                return None, None
+
+            dl_res = session.get(
+                f"{host}{download_path}",
+                timeout=10,
+                allow_redirects=False,
+            )
+            if dl_res.status_code == 401:
+                return 'password_required', None
+            if dl_res.status_code in (301, 302, 303, 307, 308):
+                b2_url = dl_res.headers["Location"]
+            elif dl_res.ok:
+                return "file", (dl_res.content, filename)
+            else:
+                msg = f"Download redirect failed (HTTP {dl_res.status_code})"
+                err(f"{msg}.")
+                _report("get", msg)
+                return None, None
+
+        bar        = ProgressBar(max(filesize, 1), label="downloading")
+        chunks     = []
+        downloaded = 0
+        retries    = 3
+
+        for attempt in range(retries + 1):
+            req_headers = {}
+            if downloaded:
+                req_headers["Range"] = f"bytes={downloaded}-"
+            try:
+                with _requests.get(b2_url, stream=True, timeout=30,
+                                   headers=req_headers) as stream:
+                    if stream.status_code not in (200, 206):
+                        msg = f"B2 download failed (HTTP {stream.status_code})"
+                        err(f"{msg}.")
+                        _report("get", msg)
+                        return None, None
+                    for chunk in stream.iter_content(chunk_size=CHUNK):
+                        if chunk:
+                            chunks.append(chunk)
+                            downloaded += len(chunk)
+                            bar.update(len(chunk))
+                break  # success — exit retry loop
+            except (_requests.exceptions.ChunkedEncodingError,
+                    _requests.exceptions.ConnectionError) as exc:
+                if attempt < retries:
+                    import time as _time
+                    _time.sleep(1)
+                    continue
+                err(f"Download failed after {retries + 1} attempts: {exc}")
+                return None, None
+
+        bar.done()
+        return "file", (b"".join(chunks), filename)
+
+    except Exception as e:
+        err(f"Get error: {e}")
+        raise
+
+
+def _handle_error(res, prefix):
+    try:
+        msg = res.json().get("error", res.text[:200])
+    except Exception:
+        msg = res.text[:200]
+    err(f"{prefix}: {msg}")
+
+
+def _handle_http_error(res, key):
+    if res.status_code == 404:
+        err(f"File /f/{key}/ not found.")
+    elif res.status_code == 410:
+        err(f"File /f/{key}/ has expired.")
+    else:
+        msg = f"Server returned {res.status_code}"
+        err(f"{msg}.")
+        _report("get", msg)
+
+
+# ── Remote URL upload ─────────────────────────────────────────────────────────
+
+def upload_from_url(host, session, url, key=None, expiry_days=None,
+                    password=None, is_test=False, schedule=None,
+                    webhook_url=None, notify=None, is_public=False, tags=None):
+    """
+    Ask the server to fetch a URL and store it as a file drop.
+    Returns (key, filename, filesize) on success, None on failure.
+    """
+    payload = {"url": url}
+    if key:
+        payload["key"] = key
+    if expiry_days:
+        payload["expiry_days"] = expiry_days
+    if password:
+        payload["password"] = password
+    if is_test:
+        payload["is_test"] = True
+    if schedule:
+        payload["schedule"] = schedule
+    if webhook_url:
+        payload["webhook_url"] = webhook_url
+    if notify:
+        payload["notify"] = notify
+    if is_public:
+        payload["is_public"] = True
+    if tags:
+        payload["tags"] = tags
+
+    try:
+        csrf = get_csrf(host, session)
+        res = session.post(
+            f"{host}/upload/from-url/",
+            json=payload,
+            headers={"X-CSRFToken": csrf},
+            timeout=120,  # server-side fetch can take a while
+        )
+        if not res.ok:
+            _handle_error(res, "Remote upload failed")
+            _report("up", f"upload_from_url HTTP {res.status_code}")
+            return None
+        _touch_session()
+        data = res.json()
+        return data.get("key"), data.get("filename", ""), data.get("filesize", 0)
+    except Exception as e:
+        err(f"Remote upload error: {e}")
+        raise

cli/api/helpers.py

@@ -0,0 +1,28 @@
+"""
+Small utilities shared across CLI API modules.
+"""
+
+import sys
+from pathlib import Path
+
+
+def slug(name):
+    """Turn a filename into a url-safe slug (max 40 chars)."""
+    import secrets
+    import re
+    stem = Path(name).stem
+    safe = ''.join(c if c.isalnum() or c in '-_' else '-' for c in stem).strip('-')
+    safe = re.sub(r'-{2,}', '-', safe)  # collapse consecutive hyphens
+    return safe[:40] or secrets.token_urlsafe(6)
+
+
+def err(msg):
+    """Print a formatted error to stderr."""
+    from cli.format import red
+    print(f'  {red("✗", stream=sys.stderr)} {msg}', file=sys.stderr)
+
+
+def ok(msg):
+    """Print a formatted success message."""
+    from cli.format import green
+    print(f'  {green("✓")} {msg}')