mycloudctl 1.0.0__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,2 @@
+# cli/__init__.py
+__version__ = "1.0.0"

cli/__main__.py

@@ -0,0 +1,138 @@
+"""
+__main__.py  myCloud CLI entry point.
+
+Usage:
+    mycloud <command> [subcommand] [options]
+
+Install:
+    pip install -e ./cli
+    # then just run: mycloud
+"""
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from cli.commands import auth, files, folders, stash, share, batch
+from cli.commands import favorites, search, servers, notifications, profile
+from cli.commands import storage, prefs
+
+console = Console()
+
+app = typer.Typer(
+    name="mycloudctl",
+    help="""
+[bold cyan]myCloud CLI[/bold cyan]  Your cloud storage from the terminal.
+
+[dim]Get started:[/dim]
+  mycloudctl login              Sign in to myCloud
+  mycloudctl ls                 Browse your files
+  mycloudctl upload <file>      Upload a file
+  mycloudctl upload <file> --stash  Upload directly to stash
+  mycloudctl download <id>      Download a file
+  mycloudctl info <id>          Show file details
+  mycloudctl stats              Show storage usage
+  mycloudctl find <query>       Search files and folders
+  mycloudctl --help             Show this help
+""",
+    rich_markup_mode="rich",
+    add_completion=True,
+    no_args_is_help=True,
+)
+
+# ------------------------------------------------------------------ #
+# Top-level auth commands (login, logout, whoami)
+# ------------------------------------------------------------------ #
+app.add_typer(auth.app, name="auth", hidden=True)  # namespace for power users
+app.command("login")(auth.login)
+app.command("logout")(auth.logout)
+app.command("whoami")(auth.whoami)
+app.command("register")(auth.register)
+
+# ------------------------------------------------------------------ #
+# File operations
+# ------------------------------------------------------------------ #
+app.command("ls")(files.ls)
+app.command("upload")(files.upload)
+app.command("download")(files.download)
+app.command("rm")(files.rm)
+app.command("rename")(files.rename)
+app.command("mv")(files.mv)
+app.command("info")(files.info)        # <-- file info shortcut
+app.command("favorite")(files.favorite)
+app.command("cat")(files.cat)
+app.command("download-all")(files.download_all)
+app.command("rm-all")(files.remove_all)
+
+# ------------------------------------------------------------------ #
+# Folder operations (sub-group)
+# ------------------------------------------------------------------ #
+app.add_typer(folders.app, name="folders")
+# Also expose mkdir directly at the top level for convenience
+app.command("mkdir")(folders.mkdir)
+app.command("rmdir")(folders.rmdir)
+
+# ------------------------------------------------------------------ #
+# Stash
+# ------------------------------------------------------------------ #
+app.add_typer(stash.app, name="stash")
+
+# ------------------------------------------------------------------ #
+# Favorites shortcut
+# ------------------------------------------------------------------ #
+app.command("fav")(favorites.fav_toggle)
+
+# ------------------------------------------------------------------ #
+# Search
+# ------------------------------------------------------------------ #
+app.command("find")(search.find)
+
+# ------------------------------------------------------------------ #
+# Sharing
+# ------------------------------------------------------------------ #
+app.add_typer(share.app, name="share")
+
+# ------------------------------------------------------------------ #
+# Batch operations
+# ------------------------------------------------------------------ #
+app.add_typer(batch.app, name="batch")
+
+# ------------------------------------------------------------------ #
+# Private servers / nodes
+# ------------------------------------------------------------------ #
+app.add_typer(servers.app, name="servers")
+
+# ------------------------------------------------------------------ #
+# Notifications
+# ------------------------------------------------------------------ #
+app.add_typer(notifications.app, name="notify")
+
+# ------------------------------------------------------------------ #
+# Profile & settings
+# ------------------------------------------------------------------ #
+app.add_typer(profile.app, name="profile")
+
+# ------------------------------------------------------------------ #
+# Storage stats
+# ------------------------------------------------------------------ #
+app.add_typer(storage.app, name="storage")
+app.command("stats")(storage.stats)    # <-- top-level shortcut
+
+# ------------------------------------------------------------------ #
+# User preferences
+# ------------------------------------------------------------------ #
+app.add_typer(prefs.app, name="prefs")
+
+# ------------------------------------------------------------------ #
+# Version
+# ------------------------------------------------------------------ #
+
+@app.command("version")
+def version_cmd():
+    """Show the myCloud CLI version."""
+    from cli import __version__
+    console.print(f"[bold]myCloud CLI[/bold] v{__version__}")
+
+
+if __name__ == "__main__":
+    app()

cli/api.py

@@ -0,0 +1,323 @@
+"""
+api.py  myCloud HTTP client.
+
+All CLI commands use CloudClient to communicate with the server.
+Handles:
+  - Bearer token injection
+  - 401  friendly re-login message
+  - Streaming uploads and downloads with Rich progress bars
+  - JSON error unwrapping
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Generator, IO
+
+import httpx
+from rich.console import Console
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    BarColumn,
+    DownloadColumn,
+    TransferSpeedColumn,
+    TimeRemainingColumn,
+    TextColumn,
+)
+
+from cli.config import get_base_url, get_token
+
+console = Console()
+
+_CHUNK = 1024 * 64  # 64 KB read/write chunks
+
+
+class APIError(Exception):
+    """Raised when the server returns a non-2xx status."""
+    def __init__(self, message: str, status_code: int = 0):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class CloudClient:
+    """Thin httpx wrapper with auth + progress for the myCloud CLI."""
+
+    def __init__(self, base_url: str | None = None, token: str | None = None):
+        self.base_url = (base_url or get_base_url()).rstrip("/")
+        self.token = token or get_token()
+
+    # ------------------------------------------------------------------ #
+    # Internal helpers
+    # ------------------------------------------------------------------ #
+
+    def _headers(self, extra: dict | None = None) -> dict:
+        h = {
+            "Accept": "application/json",
+            "X-Requested-With": "XMLHttpRequest"
+        }
+        if self.token:
+            h["Authorization"] = f"Bearer {self.token}"
+        if extra:
+            h.update(extra)
+        return h
+
+    def _url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+    def _raise(self, resp: httpx.Response) -> None:
+        if resp.status_code == 401:
+            try:
+                msg = resp.json().get("error")
+                if msg:
+                    raise APIError(msg, 401)
+            except Exception as e:
+                # If we've raised APIError inside the try, re-raise it
+                if isinstance(e, APIError):
+                    raise e
+                pass
+                
+            raise APIError(
+                "Not authenticated. Run [bold]mycloud login[/bold] first.",
+                401,
+            )
+            
+        if not resp.is_success:
+            try:
+                body = resp.json()
+                msg = body.get("error") or body.get("message") or resp.text
+            except Exception:
+                msg = resp.text or f"HTTP {resp.status_code}"
+            raise APIError(msg, resp.status_code)
+
+    # ------------------------------------------------------------------ #
+    # JSON endpoints
+    # ------------------------------------------------------------------ #
+
+    def get(self, path: str, **params) -> Any:
+        resp = httpx.get(
+            self._url(path),
+            params=params or None,
+            headers=self._headers(),
+            follow_redirects=True,
+            timeout=30,
+        )
+        self._raise(resp)
+        return resp.json()
+
+    def get_raw(self, path: str) -> str:
+        resp = httpx.get(
+            self._url(path),
+            headers=self._headers(),
+            follow_redirects=True,
+            timeout=30,
+        )
+        self._raise(resp)
+        return resp.text
+    def post(self, path: str, json: Any = None, data: dict | None = None,
+             files: dict | None = None, extra_headers: dict | None = None) -> Any:
+        h = self._headers(extra_headers)
+        if files:
+            # multipart  don't set Content-Type, httpx handles it
+            resp = httpx.post(
+                self._url(path), headers=h, data=data or {},
+                files=files, timeout=None, follow_redirects=True,
+            )
+        else:
+            resp = httpx.post(
+                self._url(path), headers=h, json=json,
+                timeout=30, follow_redirects=True,
+            )
+        self._raise(resp)
+        return resp.json()
+
+    def delete(self, path: str, json: Any = None) -> Any:
+        if json is not None:
+            resp = httpx.request(
+                "DELETE",
+                self._url(path),
+                headers=self._headers(),
+                json=json,
+                follow_redirects=True,
+                timeout=30,
+            )
+        else:
+            resp = httpx.delete(
+                self._url(path),
+                headers=self._headers(),
+                follow_redirects=True,
+                timeout=30,
+            )
+        self._raise(resp)
+        return resp.json()
+
+    # ------------------------------------------------------------------ #
+    # Streaming upload
+    # ------------------------------------------------------------------ #
+
+    def upload_avatar(self, local_path: Path) -> Any:
+        with open(local_path, "rb") as f:
+            resp = httpx.post(
+                self._url("/upload_pfp"),
+                headers=self._headers(),
+                files={"file": (local_path.name, f, "image/jpeg")},
+                timeout=30, follow_redirects=True,
+            )
+        self._raise(resp)
+        return resp.json()
+
+    def upload_file(
+        self,
+        local_path: Path,
+        folder_id: int | None = None,
+        node: str = "central",
+        stash: bool = False,
+    ) -> Any:
+        """Upload a single file with a Rich progress bar."""
+        file_size = local_path.stat().st_size
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.fields[filename]}"),
+            BarColumn(),
+            DownloadColumn(),
+            TransferSpeedColumn(),
+            TimeRemainingColumn(),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task(
+                "upload", filename=local_path.name, total=file_size
+            )
+
+            class TrackedFile:
+                def __init__(self, f: IO[bytes]):
+                    self._f = f
+
+                def read(self, n: int = -1) -> bytes:
+                    chunk = self._f.read(n)
+                    progress.update(task, advance=len(chunk))
+                    return chunk
+
+                def fileno(self):
+                    return self._f.fileno()
+
+            with open(local_path, "rb") as f:
+                tracked = TrackedFile(f)
+                form_data: dict[str, Any] = {}
+                if stash:
+                    form_data["days"] = "7"
+                elif folder_id is not None:
+                    form_data["folder_id"] = str(folder_id)
+                if node and node != "central":
+                    form_data["node"] = str(node)
+
+                endpoint = "/stash_add" if stash else "/upload"
+
+                resp = httpx.post(
+                    self._url(endpoint),
+                    headers=self._headers(),
+                    data=form_data,
+                    files={"file": (local_path.name, tracked, "application/octet-stream")},
+                    timeout=None,
+                    follow_redirects=True,
+                )
+        self._raise(resp)
+        return resp.json()
+
+    # ------------------------------------------------------------------ #
+    # Streaming download
+    # ------------------------------------------------------------------ #
+
+    def download_file(
+        self,
+        file_id: int,
+        dest_dir: Path,
+        filename: str | None = None,
+    ) -> Path:
+        """Download a file with a Rich progress bar. Returns the saved path."""
+        url = self._url(f"/download/{file_id}")
+
+        with httpx.stream(
+            "GET", url, headers=self._headers(),
+            follow_redirects=True, timeout=None,
+        ) as resp:
+            self._raise(resp)
+
+            # Determine filename from Content-Disposition or provided name
+            if not filename:
+                cd = resp.headers.get("content-disposition", "")
+                for part in cd.split(";"):
+                    part = part.strip()
+                    if part.startswith("filename="):
+                        filename = part.split("=", 1)[1].strip().strip('"')
+                        break
+                if not filename:
+                    filename = f"file_{file_id}"
+
+            dest = dest_dir / filename
+            dest_dir.mkdir(parents=True, exist_ok=True)
+
+            total = int(resp.headers.get("content-length", 0)) or None
+
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[bold green]{task.fields[filename]}"),
+                BarColumn(),
+                DownloadColumn(),
+                TransferSpeedColumn(),
+                TimeRemainingColumn(),
+                console=console,
+                transient=True,
+            ) as progress:
+                task = progress.add_task("download", filename=filename, total=total)
+                with open(dest, "wb") as f:
+                    for chunk in resp.iter_bytes(_CHUNK):
+                        f.write(chunk)
+                        progress.update(task, advance=len(chunk))
+
+        return dest
+
+    def download_folder(self, folder_id: int, dest_dir: Path) -> Path:
+        """Download a folder as a zip archive."""
+        url = self._url(f"/download_folder/{folder_id}")
+        return self._stream_zip(url, dest_dir, f"folder_{folder_id}.zip")
+
+    def download_all(self, dest_dir: Path, node: str = "central",
+                     folder_id: int | None = None) -> Path:
+        """Download all files in the current view as a zip."""
+        params: dict[str, Any] = {}
+        if folder_id is not None:
+            params["folder_id"] = folder_id
+        if node and node != "central":
+            params["node"] = node
+        url = self._url("/download_all")
+        return self._stream_zip(url, dest_dir, "mycloud_files.zip", params=params)
+
+    def _stream_zip(self, url: str, dest_dir: Path, default_name: str,
+                    params: dict | None = None) -> Path:
+        with httpx.stream(
+            "GET", url, headers=self._headers(), params=params,
+            follow_redirects=True, timeout=None,
+        ) as resp:
+            self._raise(resp)
+            cd = resp.headers.get("content-disposition", "")
+            name = default_name
+            for part in cd.split(";"):
+                part = part.strip()
+                if part.startswith("filename="):
+                    name = part.split("=", 1)[1].strip().strip('"')
+                    break
+            dest_dir.mkdir(parents=True, exist_ok=True)
+            dest = dest_dir / name
+            total = int(resp.headers.get("content-length", 0)) or None
+            with Progress(
+                SpinnerColumn(), BarColumn(), DownloadColumn(),
+                console=console, transient=True,
+            ) as progress:
+                task = progress.add_task("zip", total=total)
+                with open(dest, "wb") as f:
+                    for chunk in resp.iter_bytes(_CHUNK):
+                        f.write(chunk)
+                        progress.update(task, advance=len(chunk))
+        return dest

cli/commands/__init__.py

@@ -0,0 +1 @@
+# cli/commands/__init__.py

cli/commands/auth.py

@@ -0,0 +1,234 @@
+"""commands/auth.py  login, logout, whoami commands."""
+from __future__ import annotations
+
+import sys
+import time
+import webbrowser
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich import print as rprint
+
+from cli.api import CloudClient, APIError
+from cli.config import (
+    save_credentials, clear_credentials, get_base_url,
+    get_token, get_stored_user,
+)
+
+app = typer.Typer(help="Authentication  login, logout, and account info.")
+console = Console()
+
+
+@app.command("login")
+def login(
+    username: str = typer.Option(None, "--username", "-u", help="Username or email"),
+    password: str = typer.Option(None, "--password", "-p", help="Password (prefer interactive prompt)"),
+    server: str = typer.Option(None, "--server", "-s", help="Override server URL"),
+):
+    """Log in to myCloud and save credentials locally."""
+    base_url = server or get_base_url()
+    client = CloudClient(base_url=base_url, token="")
+
+    console.print(Panel.fit(
+        "[bold cyan]myCloud CLI[/bold cyan]  -  Sign in",
+        border_style="cyan",
+    ))
+    console.print(f"[dim]Server:[/dim] {base_url}\n")
+
+    identifier = username or Prompt.ask("[bold]Username or email[/]")
+    pwd = password or Prompt.ask("[bold]Password[/]", password=True)
+
+    try:
+        data = client.post("/api/auth/token", json={
+            "username": identifier,
+            "password": pwd,
+            "label": "CLI",
+        })
+    except APIError as e:
+        console.print(f"[red]- Login failed:[/red] {e}")
+        raise typer.Exit(1)
+
+    if data.get("two_factor_required"):
+        _handle_2fa(client, data["login_id"], base_url)
+        return
+
+    _store_and_greet(data, base_url)
+
+
+def _handle_2fa(client: CloudClient, login_id: str, base_url: str) -> None:
+    """Open the 2FA email link in the browser and poll until verified."""
+    verify_url = f"{base_url}/2fa/verify"
+    console.print(
+        "\n[bold yellow]  Two-factor authentication required.[/]\n"
+        "A verification email has been sent to your inbox.\n"
+        "Opening your browser so you can click the link\n"
+    )
+    try:
+        webbrowser.open(f"{base_url}/login")
+    except Exception:
+        pass
+
+    console.print("[dim]Waiting for you to click the email link[/dim]")
+
+    with console.status("[cyan]Polling for 2FA confirmation[/cyan]", spinner="dots"):
+        while True:
+            time.sleep(2)
+            try:
+                poll = client.get("/api/auth/2fa-poll", login_id=login_id, label="CLI")
+            except APIError as e:
+                console.print(f"[red]Poll error:[/] {e}")
+                raise typer.Exit(1)
+
+            status = poll.get("status")
+            if status == "verified":
+                _store_and_greet(poll, client.base_url)
+                return
+            elif status == "expired":
+                console.print("[red]- 2FA link expired. Please run login again.[/]")
+                raise typer.Exit(1)
+            elif status in ("invalid",):
+                console.print("[red]- 2FA session invalid.[/]")
+                raise typer.Exit(1)
+            # status == "pending"  keep waiting
+
+
+def _store_and_greet(data: dict, base_url: str) -> None:
+    user = data.get("user", {})
+    save_credentials({
+        "token": data["token"],
+        "expires_at": data.get("expires_at", ""),
+        "base_url": base_url,
+        "user": user,
+    })
+    console.print(
+        f"\n[bold green] Logged in as [cyan]{user.get('username', '?')}[/cyan]"
+        f"  ({user.get('name', '')})[/bold green]"
+    )
+    console.print(f"[dim]Token expires: {data.get('expires_at', 'unknown')}[/dim]\n")
+    console.print("Run [bold]mycloud ls[/bold] to browse your files.")
+
+
+@app.command("logout")
+def logout():
+    """Revoke the current token and clear local credentials."""
+    token = get_token()
+    if not token:
+        console.print("[yellow]Not logged in.[/yellow]")
+        raise typer.Exit()
+
+    client = CloudClient()
+    try:
+        client.delete("/api/auth/token")
+        console.print("[green] Logged out (token revoked on server).[/green]")
+    except APIError:
+        console.print("[yellow]Could not reach server  clearing local credentials anyway.[/yellow]")
+    finally:
+        clear_credentials()
+
+
+@app.command("whoami")
+def whoami():
+    """Show the currently authenticated user and storage usage."""
+    user = get_stored_user()
+    if not user:
+        console.print("[yellow]Not logged in. Run [bold]mycloud login[/bold].[/yellow]")
+        raise typer.Exit(1)
+
+    console.print(Panel(
+        f"[bold cyan]{user.get('name', user.get('username'))}[/bold cyan]\n"
+        f"[dim]Username:[/dim] {user.get('username', '?')}\n"
+        f"[dim]Email:[/dim]    {user.get('email', '?')}\n"
+        f"[dim]Server:[/dim]   {get_base_url()}",
+        title="[bold]Signed In[/bold]",
+        border_style="green",
+    ))
+
+
+@app.command("register")
+def register(
+    name: str = typer.Option(None, "--name", "-n", help="Full name"),
+    username: str = typer.Option(None, "--username", "-u", help="Username"),
+    email: str = typer.Option(None, "--email", "-e", help="Email address"),
+    password: str = typer.Option(None, "--password", "-p", help="Password"),
+):
+    """Register a new myCloud account."""
+    client = CloudClient(base_url=get_base_url(), token="")
+    
+    console.print(Panel.fit(
+        "[bold cyan]myCloud CLI[/bold cyan]  -  Register",
+        border_style="cyan",
+    ))
+
+    _name = name or Prompt.ask("[bold]Full name[/]")
+    _username = username or Prompt.ask("[bold]Username[/]")
+    _email = email or Prompt.ask("[bold]Email[/]")
+    _pwd = password or Prompt.ask("[bold]Password[/]", password=True)
+    _pwd_confirm = Prompt.ask("[bold]Confirm Password[/]", password=True) if not password else password
+
+    if _pwd != _pwd_confirm:
+        console.print("[red]- Passwords do not match.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        data = client.post("/register", json={
+            "name": _name,
+            "username": _username,
+            "email": _email,
+            "password": _pwd,
+            "confirm_password": _pwd_confirm
+        })
+        if data.get("success"):
+            console.print(f"[green][OK][/green] {data.get('message')}")
+        else:
+            console.print(f"[red][FAIL][/red] {data.get('error') or data.get('message', 'Registration failed')}")
+    except APIError as e:
+        console.print(f"[red]- Registration failed:[/red] {e}")
+
+
+@app.command("forgot-password")
+def forgot_password(
+    email: str = typer.Option(None, "--email", "-e", help="Account email address"),
+):
+    """Request a password reset link."""
+    client = CloudClient(base_url=get_base_url(), token="")
+    
+    _email = email or Prompt.ask("[bold]Email[/]")
+
+    try:
+        data = client.post("/forgot_password", json={"email": _email})
+        if data.get("success"):
+            console.print(f"[green][OK][/green] {data.get('message')}")
+        else:
+            console.print(f"[red][FAIL][/red] {data.get('error', 'Request failed')}")
+    except APIError as e:
+        console.print(f"[red]- Request failed:[/red] {e}")
+
+
+@app.command("reset-password")
+def reset_password(
+    token: str = typer.Argument(..., help="Reset token from your email"),
+    password: str = typer.Option(None, "--password", "-p", help="New Password"),
+):
+    """Reset your password using a token."""
+    client = CloudClient(base_url=get_base_url(), token="")
+    
+    _pwd = password or Prompt.ask("[bold]New Password[/]", password=True)
+    _pwd_confirm = Prompt.ask("[bold]Confirm Password[/]", password=True) if not password else password
+
+    if _pwd != _pwd_confirm:
+        console.print("[red]- Passwords do not match.[/red]")
+        raise typer.Exit(1)
+
+    try:
+        data = client.post(f"/reset_password/{token}", json={
+            "password": _pwd,
+            "confirm_password": _pwd_confirm
+        })
+        if data.get("success"):
+            console.print(f"[green][OK][/green] {data.get('message')}")
+        else:
+            console.print(f"[red][FAIL][/red] {data.get('error', 'Reset failed')}")
+    except APIError as e:
+        console.print(f"[red]- Reset failed:[/red] {e}")