mycloudctl 1.0.0__py3-none-any.whl

cli/commands/folders.py

@@ -0,0 +1,200 @@
+"""commands/folders.py -- mkdir, rm, rename, info commands."""
+from __future__ import annotations
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+
+from cli.api import CloudClient, APIError
+
+app = typer.Typer(help="Folder management -- create and manage folders.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+def _fmt(b: int | float | None) -> str:
+    import math
+    if b is None:
+        return "-"
+    b = float(b)
+    if b == 0:
+        return "0 B"
+    units = ["B", "KB", "MB", "GB", "TB"]
+    idx = min(int(math.log(b, 1024)), len(units) - 1)
+    return f"{b / (1024 ** idx):.1f} {units[idx]}"
+
+
+@app.command("mkdir")
+def mkdir(
+    name: str = typer.Argument(..., help="Folder name"),
+    parent_id: Optional[int] = typer.Option(None, "--parent", "-p", help="Parent folder ID"),
+    node: str = typer.Option("central", "--node", "-n", help="Storage node"),
+):
+    """Create a new folder."""
+    client = _client()
+    body: dict = {"folder_name": name}
+    if parent_id is not None:
+        body["parent_id"] = parent_id
+    if node != "central":
+        body["storage_mode"] = node
+
+    try:
+        result = client.post("/create_folder", json=body)
+        folder_id = result.get("folder_id") or result.get("id")
+        if result.get("success") or folder_id:
+            console.print(f"[green][OK][/] Folder '[bold]{name}[/]' created (id={folder_id}).")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("rm")
+def rmdir(
+    folder_id: int = typer.Argument(..., help="Folder ID to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete a folder and ALL its contents. Cannot be undone."""
+    if not yes:
+        typer.confirm(
+            f"Delete folder {folder_id} and all its contents? This cannot be undone.",
+            abort=True,
+        )
+    client = _client()
+    try:
+        result = client.post(f"/delete_folder/{folder_id}")
+        if result.get("success"):
+            console.print(f"[green][OK][/] Folder {folder_id} deleted.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("rename")
+def rename_folder(
+    folder_id: int = typer.Argument(..., help="Folder ID to rename"),
+    new_name: str = typer.Argument(..., help="New folder name"),
+):
+    """Rename a folder."""
+    client = _client()
+    try:
+        result = client.post(f"/rename_folder/{folder_id}", json={"name": new_name})
+        if result.get("success"):
+            actual = result.get("new_name", new_name)
+            console.print(f"[green][OK][/] Folder renamed to '[bold]{actual}[/]'.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("info")
+def folder_info(
+    folder_id: int = typer.Argument(..., help="Folder ID"),
+):
+    """Show detailed info about a folder."""
+    client = _client()
+    try:
+        data = client.get(f"/api/folder_details/{folder_id}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+        raise typer.Exit(1)
+
+    folder = data.get("folder") or data
+    files = data.get("files", [])
+    subfolders = data.get("subfolders") or data.get("folders", [])
+
+    console.print(Panel(
+        f"[bold]{folder.get('name', '?')}[/bold]\n"
+        f"[dim]ID:[/dim]       {folder.get('id', '?')}\n"
+        f"[dim]Parent ID:[/dim] {folder.get('parent_id') or 'root'}\n"
+        f"[dim]Created:[/dim]   {str(folder.get('created_at', '?'))[:16]}\n"
+        f"[dim]Storage:[/dim]   {folder.get('storage_mode') or 'central'}\n"
+        f"[dim]Files:[/dim]     {len(files)}\n"
+        f"[dim]Subfolders:[/dim] {len(subfolders)}",
+        title=f"[bold]Folder Details[/bold]",
+        border_style="magenta",
+    ))
+
+    if subfolders:
+        t = Table(title="Subfolders", box=box.SIMPLE, header_style="bold magenta")
+        t.add_column("ID", style="dim", justify="right")
+        t.add_column("Name")
+        for sf in subfolders:
+            t.add_row(str(sf.get("id", "?")), sf.get("name", "-"))
+        console.print(t)
+
+    if files:
+        t = Table(title="Files", box=box.SIMPLE, header_style="bold cyan")
+        t.add_column("ID", style="dim", justify="right")
+        t.add_column("Name")
+        t.add_column("Size", justify="right", style="green")
+        for f in files:
+            t.add_row(
+                str(f.get("id", "?")),
+                f.get("original_filename") or f.get("name") or "-",
+                _fmt(f.get("file_size") or f.get("size")),
+            )
+        console.print(t)
+
+
+@app.command("mv")
+def mv(
+    folder_id: int = typer.Argument(..., help="Folder ID to move"),
+    dest_id: int = typer.Argument(..., help="Destination parent folder ID (0 for root)"),
+):
+    """Move a folder to another parent folder."""
+    client = _client()
+    try:
+        dest_val = None if dest_id == 0 else dest_id
+        result = client.post("/api/move_folder", json={
+            "folder_id": folder_id,
+            "destination_folder_id": dest_val
+        })
+        if result.get("success"):
+            console.print(f"[green][OK][/] Folder {folder_id} moved to folder {dest_id}.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('error') or result.get('message', 'Move failed')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("download")
+def download(
+    folder_id: int = typer.Argument(..., help="Folder ID to download"),
+    output: str = typer.Option(".", "--output", "-o", help="Output directory"),
+):
+    """Download a folder and its contents as a zip archive."""
+    from pathlib import Path
+    client = _client()
+    out_dir = Path(output)
+    
+    console.print(f"[cyan]Preparing download for folder {folder_id}[/]")
+    try:
+        path = client.download_folder(folder_id, out_dir)
+        console.print(f"[green][OK][/] Saved to [bold]{path}[/bold]")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("favorite")
+def favorite(
+    folder_id: int = typer.Argument(..., help="Folder ID"),
+):
+    """Toggle favorite status for a folder."""
+    client = _client()
+    try:
+        result = client.post(f"/api/folders/{folder_id}/favorite")
+        state = result.get("is_favorite")
+        icon = "[red][/]" if state else "[dim][/]"
+        label = "Favorited" if state else "Un-favorited"
+        console.print(f"{icon} {label} folder {folder_id}.")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")

cli/commands/notifications.py

@@ -0,0 +1,79 @@
+"""commands/notifications.py  list and mark-read notifications."""
+from __future__ import annotations
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from cli.api import CloudClient, APIError
+from cli.ui.table import notifications_table
+
+app = typer.Typer(help="Notifications  view and manage your notifications.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("ls")
+def notif_ls(
+    limit: int = typer.Option(20, "--limit", "-l", help="Max notifications to show"),
+):
+    """List your notifications."""
+    client = _client()
+    try:
+        data = client.get("/api/notifications", limit=limit)
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    notifs = data.get("notifications", []) or data.get("data", [])
+    if not notifs:
+        console.print("[dim]No notifications.[/dim]")
+        return
+    console.print(notifications_table(notifs))
+
+
+@app.command("read")
+def notif_read(
+    ids: Optional[str] = typer.Argument(None,
+        help="Comma-separated notification IDs to mark read, or omit to mark all."),
+):
+    """Mark notifications as read."""
+    client = _client()
+    body: dict = {}
+    if ids:
+        id_list = [int(x.strip()) for x in ids.split(",") if x.strip().isdigit()]
+        body["notification_ids"] = id_list
+
+    try:
+        result = client.post("/api/notifications/mark_read", json=body)
+        if result.get("success"):
+            console.print("[green][OK][/] Notifications marked as read.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("hide")
+def notif_hide(
+    ids: str = typer.Argument(..., help="Comma-separated notification IDs to hide"),
+):
+    """Permanently hide notifications by ID."""
+    client = _client()
+    id_list = [int(x.strip()) for x in ids.split(",") if x.strip().isdigit()]
+    if not id_list:
+        console.print("[yellow]No valid IDs provided.[/yellow]")
+        raise typer.Exit(1)
+
+    try:
+        result = client.post("/api/notifications/hide", json={"notification_ids": id_list})
+        if result.get("success"):
+            console.print(f"[green][OK][/] {len(id_list)} notification(s) hidden.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+

cli/commands/prefs.py

@@ -0,0 +1,72 @@
+"""commands/prefs.py -- user preferences management."""
+from __future__ import annotations
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from cli.api import CloudClient, APIError
+
+app = typer.Typer(help="Preferences -- view and update your account preferences.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("show")
+def prefs_show():
+    """Display all your current preferences."""
+    client = _client()
+    try:
+        data = client.get("/api/user_preferences")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+        raise typer.Exit(1)
+
+    prefs = data.get("preferences") or data.get("data") or data
+    if not prefs or not isinstance(prefs, dict):
+        console.print("[dim]No preferences found.[/dim]")
+        return
+
+    t = Table(title="Your Preferences", box=box.ROUNDED, header_style="bold cyan")
+    t.add_column("Key", style="bold")
+    t.add_column("Value")
+
+    for k, v in prefs.items():
+        t.add_row(str(k), str(v))
+    console.print(t)
+
+
+@app.command("set")
+def prefs_set(
+    key: str = typer.Argument(..., help="Preference key"),
+    value: str = typer.Argument(..., help="New value"),
+):
+    """Set a user preference key to a value."""
+    client = _client()
+    try:
+        result = client.post("/api/user_preferences", json={key: value})
+        if result.get("success") is not False:
+            console.print(f"[green][OK][/] Preference '[bold]{key}[/]' set to '[bold]{value}[/]'.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("sync")
+def prefs_sync():
+    """Sync preferences across devices."""
+    client = _client()
+    try:
+        result = client.post("/api/user_preferences/sync")
+        if result.get("success") is not False:
+            console.print("[green][OK][/] Preferences synced.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")

cli/commands/profile.py

@@ -0,0 +1,157 @@
+"""commands/profile.py  view/update profile, 2FA toggle, change password."""
+from __future__ import annotations
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+from cli.api import CloudClient, APIError
+from cli.config import get_stored_user
+
+app = typer.Typer(help="Profile  view and update your account settings.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("show")
+def profile_show():
+    """Display your profile information."""
+    user = get_stored_user()
+    if not user:
+        console.print("[yellow]Not logged in.[/yellow]")
+        raise typer.Exit(1)
+
+    client = _client()
+    try:
+        data = client.get("/settings")
+    except APIError as e:
+        # Fall back to cached data
+        data = {}
+
+    u = data.get("user") or user
+
+    console.print(Panel(
+        f"[bold]{u.get('name', '?')}[/bold]\n"
+        f"[dim]Username:[/dim] {u.get('username', '?')}\n"
+        f"[dim]Email:[/dim]    {u.get('email', '?')}\n"
+        f"[dim]2FA:[/dim]      {'[green]enabled[/]' if u.get('two_factor_enabled') else '[dim]disabled[/]'}\n"
+        f"[dim]Member since:[/dim] {str(u.get('created_at', '?'))[:10]}",
+        title="[bold]Your Profile[/bold]",
+        border_style="cyan",
+    ))
+
+
+@app.command("update")
+def profile_update(
+    name: Optional[str] = typer.Option(None, "--name", help="Display name"),
+    username: Optional[str] = typer.Option(None, "--username", help="New username"),
+):
+    """Update your display name or username."""
+    if not name and not username:
+        console.print("[yellow]Provide --name or --username to update.[/yellow]")
+        raise typer.Exit(1)
+
+    client = _client()
+    body: dict = {}
+    if name:
+        body["name"] = name
+    if username:
+        body["username"] = username
+
+    try:
+        result = client.post("/update_profile", json=body)
+        if result.get("success"):
+            console.print("[green][/] Profile updated.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("2fa")
+def profile_2fa(
+    enable: Optional[bool] = typer.Option(None, "--enable/--disable",
+                                           help="Enable or disable 2FA"),
+):
+    """Toggle two-factor authentication."""
+    if enable is None:
+        user = get_stored_user()
+        current = bool(user.get("two_factor_enabled"))
+        enable = not current
+        console.print(f"[dim]Currently: {'enabled' if current else 'disabled'}. Toggling[/dim]")
+
+    client = _client()
+    try:
+        result = client.post("/settings/two-factor", json={"enabled": enable})
+        if result.get("success"):
+            state = "enabled" if enable else "disabled"
+            console.print(f"[green][/] 2FA {state}.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("avatar-upload")
+def avatar_upload(
+    image: Path = typer.Argument(..., help="Path to the image file"),
+):
+    """Upload a new profile picture."""
+    if not image.exists() or not image.is_file():
+        console.print(f"[red]File not found:[/] {image}")
+        raise typer.Exit(1)
+        
+    client = _client()
+    try:
+        result = client.upload_avatar(image)
+        if result.get("success"):
+            console.print("[green][OK][/] Profile picture uploaded successfully.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("avatar-rm")
+def avatar_remove():
+    """Remove your current profile picture."""
+    client = _client()
+    try:
+        result = client.post("/remove_pfp")
+        if result.get("success"):
+            console.print("[green][OK][/] Profile picture removed.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("delete-account")
+def profile_delete_account(
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Confirm deletion without prompting"),
+):
+    """Permanently delete your account and all associated data."""
+    if not confirm:
+        sure = Prompt.ask("[bold red]Are you absolutely sure you want to delete your account? This cannot be undone[/bold red] (y/N)")
+        if sure.lower() not in ('y', 'yes'):
+            console.print("Account deletion aborted.")
+            raise typer.Exit()
+            
+    client = _client()
+    try:
+        result = client.post("/delete_account")
+        if result.get("success"):
+            console.print(f"[green][OK][/] {result.get('message', 'Account deleted.')}")
+            # Clear local config since we are logged out
+            from cli.config import clear_credentials
+            clear_credentials()
+        else:
+            console.print(f"[red]-[/] {result.get('error', 'Error deleting account.')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")

cli/commands/search.py

@@ -0,0 +1,78 @@
+"""commands/search.py  live search (find) command."""
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from cli.api import CloudClient, APIError
+
+app = typer.Typer(help="Search files and folders.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("find")
+def find(
+    query: str = typer.Argument(..., help="Search query"),
+    node: str = typer.Option("central", "--node", "-n", help="Node to search in"),
+):
+    """Search for files and folders by name."""
+    client = _client()
+    try:
+        data = client.get("/live_search", q=query, node=node)
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    if isinstance(data, list):
+        files = [item for item in data if item.get("item_type") == "file"]
+        folders = [item for item in data if item.get("item_type") == "folder"]
+    else:
+        files = data.get("files", [])
+        folders = data.get("folders", [])
+
+    if not files and not folders:
+        console.print(f"[dim]No results for '[bold]{query}[/]'.[/dim]")
+        return
+
+    t = Table(
+        title=f"Results for '{query}'",
+        box=box.ROUNDED,
+        header_style="bold cyan",
+    )
+    t.add_column("ID", justify="right", style="dim")
+    t.add_column("Type")
+    t.add_column("Name")
+    t.add_column("Size / Created", style="dim")
+
+    for fo in folders:
+        t.add_row(
+            str(fo.get("id", "?")),
+            " folder",
+            fo.get("name") or "",
+            str(fo.get("created_at", ""))[:16],
+        )
+    for f in files:
+        size = f.get("size") or f.get("file_size") or 0
+        t.add_row(
+            str(f.get("id", "?")),
+            " file",
+            f.get("filename") or f.get("name") or "",
+            _fmt(size),
+        )
+    console.print(t)
+    console.print(f"[dim]{len(folders)} folder(s)  {len(files)} file(s)[/dim]")
+
+
+def _fmt(b: int) -> str:
+    import math
+    units = ["B", "KB", "MB", "GB"]
+    if b == 0:
+        return "0 B"
+    idx = min(int(math.log(max(b, 1), 1024)), len(units) - 1)
+    return f"{b / (1024**idx):.1f} {units[idx]}"

cli/commands/servers.py

@@ -0,0 +1,95 @@
+"""commands/servers.py  private node (server) management."""
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+
+from cli.api import CloudClient, APIError
+
+app = typer.Typer(help="Private servers (nodes)  list, add, and remove.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("ls")
+def servers_ls():
+    """List your registered private servers (nodes)."""
+    client = _client()
+    try:
+        data = client.get("/settings/servers")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    nodes = data.get("nodes", []) or data.get("servers", [])
+    if not nodes:
+        console.print("[dim]No private servers registered.[/dim]")
+        return
+
+    t = Table(title="Private Servers", box=box.ROUNDED, header_style="bold magenta")
+    t.add_column("ID", justify="right", style="dim")
+    t.add_column("Name")
+    t.add_column("Status")
+    t.add_column("Last Seen", style="dim")
+
+    for n in nodes:
+        status = n.get("status") or n.get("is_online")
+        if status in (True, 1, "online"):
+            status_str = "[green]- online[/]"
+        else:
+            status_str = "[red]- offline[/]"
+        t.add_row(
+            str(n.get("id", "?")),
+            n.get("name") or n.get("label") or "?",
+            status_str,
+            str(n.get("last_seen") or "")[:16],
+        )
+    console.print(t)
+
+
+@app.command("add")
+def servers_add():
+    """Generate a new API key for a private server node."""
+    client = _client()
+    try:
+        result = client.post("/generate_node_key")
+        key = result.get("key") or result.get("node_key") or result.get("api_key")
+        node_id = result.get("node_id") or result.get("id")
+        if key:
+            console.print(Panel(
+                f"[bold]Node ID:[/bold] {node_id}\n"
+                f"[bold]API Key:[/bold] [cyan]{key}[/cyan]\n\n"
+                "[dim]Copy this key into your node's config. It will not be shown again.[/dim]",
+                title="[bold green]Node Created[/bold green]",
+                border_style="green",
+            ))
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error generating key')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+
+@app.command("rm")
+def servers_rm(
+    node_id: int = typer.Argument(..., help="Node ID to remove"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Remove a private server node."""
+    if not yes:
+        typer.confirm(f"Remove node {node_id}?", abort=True)
+    client = _client()
+    try:
+        result = client.post(f"/delete_node/{node_id}")
+        if result.get("success"):
+            console.print(f"[green][/] Node {node_id} removed.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")