mycloudctl 1.0.0__py3-none-any.whl

cli/commands/batch.py

@@ -0,0 +1,175 @@
+"""commands/batch.py -- batch move, delete, download, share, stash, copy-shared, link."""
+from __future__ import annotations
+from typing import List, Optional
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from cli.api import CloudClient, APIError
+
+app = typer.Typer(help="Batch operations on multiple files/folders at once.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("delete")
+def batch_delete(
+    ids: List[int] = typer.Argument(..., help="File IDs to delete"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete multiple files in one operation."""
+    if not yes:
+        typer.confirm(f"Delete {len(ids)} file(s)? Cannot be undone.", abort=True)
+    client = _client()
+    try:
+        result = client.post("/api/batch_delete", json={"file_ids": ids})
+        deleted = result.get("deleted", len(ids))
+        console.print(f"[green][OK][/] {deleted} file(s) deleted.")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("move")
+def batch_move(
+    ids: List[int] = typer.Argument(..., help="File IDs to move"),
+    dest: int = typer.Option(..., "--dest", "-d", help="Destination folder ID"),
+):
+    """Move multiple files to a folder."""
+    client = _client()
+    try:
+        result = client.post("/api/batch_move", json={"file_ids": ids, "folder_id": dest})
+        if result.get("success"):
+            console.print(f"[green][OK][/] {len(ids)} file(s) moved to folder {dest}.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("download")
+def batch_download(
+    ids: List[int] = typer.Argument(..., help="File IDs to download"),
+    output: Path = typer.Option(Path("."), "--output", "-o", help="Output directory"),
+):
+    """Download multiple files as a zip archive."""
+    client = _client()
+    console.print(f"[cyan]Preparing batch download of {len(ids)} file(s)[/]")
+    try:
+        result = client.post("/api/batch_download", json={"file_ids": ids})
+        zip_token = result.get("token") or result.get("batch_token")
+        if not zip_token:
+            console.print(f"[red]-[/] {result.get('message', 'No download token returned')}")
+            return
+        url = f"/api/batch_download?token={zip_token}"
+        path = client._stream_zip(client._url(url), output, "batch_download.zip")
+        console.print(f"[green][OK][/] Saved to [bold]{path}[/bold]")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("share")
+def batch_share(
+    ids: List[int] = typer.Argument(..., help="File IDs to share"),
+    user: str = typer.Option(..., "--user", "-u", help="Username or email of recipient"),
+    permission: str = typer.Option("read", "--permission", "-p", help="read | write"),
+):
+    """Share multiple files with a user."""
+    client = _client()
+    try:
+        result = client.post("/api/batch_share", json={
+            "file_ids": ids,
+            "email": user,
+            "permission": permission,
+        })
+        if result.get("success"):
+            console.print(f"[green][OK][/] {len(ids)} file(s) shared with [bold]{user}[/bold].")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("stash")
+def batch_stash(
+    ids: List[int] = typer.Argument(..., help="File IDs to stash"),
+    days: int = typer.Option(7, "--days", "-d", help="Expiry in days"),
+):
+    """Stash multiple files at once with an expiry period."""
+    client = _client()
+    try:
+        result = client.post("/api/batch_stash", json={"file_ids": ids, "days": days})
+        if result.get("success"):
+            console.print(f"[green][OK][/] {len(ids)} file(s) stashed for {days} day(s).")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("unstash")
+def batch_unstash(
+    ids: List[int] = typer.Argument(..., help="Stashed file IDs to restore"),
+):
+    """Restore multiple stashed files at once."""
+    client = _client()
+    try:
+        result = client.post("/api/batch_unstash", json={"file_ids": ids})
+        if result.get("success"):
+            console.print(f"[green][OK][/] {len(ids)} file(s) unstashed.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("unshare")
+def batch_unshare(
+    ids: List[int] = typer.Argument(..., help="File IDs to un-share"),
+):
+    """Remove all shares from multiple files."""
+    client = _client()
+    try:
+        result = client.post("/api/batch_remove_share", json={"file_ids": ids})
+        if result.get("success"):
+            console.print(f"[green][OK][/] Shares removed from {len(ids)} file(s).")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("copy-shared")
+def batch_copy_shared(
+    ids: List[int] = typer.Argument(..., help="Shared file IDs to copy to your cloud"),
+):
+    """Copy multiple shared files into your own storage at once."""
+    client = _client()
+    try:
+        result = client.post("/api/batch_add_to_mycloud", json={"file_ids": ids})
+        if result.get("success"):
+            console.print(f"[green][OK][/] {len(ids)} file(s) copied to your cloud.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("link")
+def batch_link(
+    ids: List[int] = typer.Argument(..., help="File IDs to generate a shared link for"),
+):
+    """Generate a single public link for multiple files."""
+    client = _client()
+    try:
+        result = client.post("/api/generate_batch_link", json={"file_ids": ids})
+        link = result.get("link") or result.get("url") or result.get("share_link")
+        if link:
+            console.print(f"[green][OK][/] Batch share link:\n[bold cyan]{link}[/bold cyan]")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Could not generate link')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")

cli/commands/favorites.py

@@ -0,0 +1,35 @@
+"""commands/favorites.py  toggle favorites on files and folders."""
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from cli.api import CloudClient, APIError
+
+app = typer.Typer(help="Favorites  toggle favorite status on files and folders.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("toggle")
+def fav_toggle(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    folder: bool = typer.Option(False, "--folder", "-f", help="ID is a folder"),
+):
+    """Toggle favorite on a file or folder."""
+    client = _client()
+    try:
+        if folder:
+            result = client.post(f"/api/folders/{item_id}/favorite")
+        else:
+            result = client.post(f"/api/files/{item_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' if folder else 'file'} {item_id}.")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")

cli/commands/files.py

@@ -0,0 +1,356 @@
+"""commands/files.py -- ls, upload, download, rm, rename, mv, info commands."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich import print as rprint
+
+from cli.api import CloudClient, APIError
+from cli.ui.table import files_table, folders_table, fmt_size
+from cli.ui.tree import build_tree
+
+app = typer.Typer(help="File operations -- list, upload, download, delete, rename, move.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+# ------------------------------------------------------------------ #
+# ls
+# ------------------------------------------------------------------ #
+
+@app.command("ls")
+def ls(
+    folder_id: Optional[int] = typer.Argument(None, help="Folder ID to list (default: root)"),
+    node: str = typer.Option("central", "--node", "-n", help="Node ID or 'central'"),
+    favorites: bool = typer.Option(False, "--favorites", "-f", help="Show favorites only"),
+    tree: bool = typer.Option(False, "--tree", "-t", help="Render as a tree"),
+):
+    """List files and folders."""
+    client = _client()
+    params: dict = {}
+    if folder_id is not None:
+        params["folder_id"] = folder_id
+    if node != "central":
+        params["node"] = node
+    if favorites:
+        params["favorites"] = "1"
+
+    try:
+        data = client.get("/", **params)
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    folders = data.get("folders", [])
+    files = data.get("files", [])
+    breadcrumb = data.get("breadcrumb", [])
+
+    if breadcrumb:
+        path_str = " / ".join(b.get("name", "?") for b in breadcrumb)
+        console.print(f"\n[dim] {path_str}[/dim]")
+
+    if tree:
+        t = build_tree(
+            folders, files,
+            root_label=f" [bold cyan]{breadcrumb[-1]['name'] if breadcrumb else 'myCloud'}[/]",
+        )
+        console.print(t)
+    else:
+        if folders:
+            console.print(folders_table(folders))
+        if files:
+            console.print(files_table(files))
+        if not folders and not files:
+            console.print("[dim]This folder is empty.[/dim]")
+
+    storage = data.get("storage_used_str") or data.get("storage_used", "")
+    if storage:
+        console.print(f"\n[dim]Storage used: {storage}[/dim]")
+
+
+# ------------------------------------------------------------------ #
+# upload
+# ------------------------------------------------------------------ #
+
+@app.command("upload")
+def upload(
+    files: List[Path] = typer.Argument(..., help="Files to upload (supports multiple)"),
+    folder_id: Optional[int] = typer.Option(None, "--folder", "-d", help="Destination folder ID"),
+    node: str = typer.Option("central", "--node", "-n", help="Target node"),
+    stash: bool = typer.Option(False, "--stash", help="Upload directly to stash"),
+):
+    """Upload one or more files to myCloud."""
+    client = _client()
+
+    for f in files:
+        if not f.exists():
+            console.print(f"[red]- File not found:[/] {f}")
+            continue
+        if not f.is_file():
+            console.print(f"[yellow] Skipping (not a file):[/] {f}")
+            continue
+
+        console.print(f"[cyan]^[/] Uploading [bold]{f.name}[/] ({fmt_size(f.stat().st_size)})")
+        try:
+            result = client.upload_file(f, folder_id=folder_id, node=node, stash=stash)
+            if result.get("success"):
+                console.print(f"[green][OK][/] {f.name} uploaded successfully.")
+            else:
+                msg = result.get("message") or result.get("error") or "Unknown error"
+                console.print(f"[red]-[/] {f.name}: {msg}")
+        except APIError as e:
+            console.print(f"[red]-[/] {f.name}: {e}")
+
+
+# ------------------------------------------------------------------ #
+# download
+# ------------------------------------------------------------------ #
+
+@app.command("download")
+def download(
+    file_ids: List[int] = typer.Argument(..., help="File ID(s) to download"),
+    output: Path = typer.Option(Path("."), "--output", "-o", help="Directory to save files"),
+    folder: Optional[int] = typer.Option(None, "--folder", help="Download an entire folder (by ID)"),
+    all_files: bool = typer.Option(False, "--all", "-a", help="Download all files as a zip"),
+    node: str = typer.Option("central", "--node", "-n", help="Node context for --all"),
+):
+    """Download file(s) from myCloud."""
+    client = _client()
+
+    if all_files:
+        console.print("[cyan][/] Downloading all files as zip")
+        try:
+            path = client.download_all(output, node=node)
+            console.print(f"[green][/] Saved to [bold]{path}[/bold]")
+        except APIError as e:
+            console.print(f"[red]-[/] {e}")
+        return
+
+    if folder is not None:
+        console.print(f"[cyan][/] Downloading folder {folder} as zip")
+        try:
+            path = client.download_folder(folder, output)
+            console.print(f"[green][/] Saved to [bold]{path}[/bold]")
+        except APIError as e:
+            console.print(f"[red]-[/] {e}")
+        return
+
+    for fid in file_ids:
+        console.print(f"[cyan][/] Downloading file {fid}")
+        try:
+            path = client.download_file(fid, output)
+            console.print(f"[green][/] Saved to [bold]{path}[/bold]")
+        except APIError as e:
+            console.print(f"[red]-[/] File {fid}: {e}")
+
+
+# ------------------------------------------------------------------ #
+# rm
+# ------------------------------------------------------------------ #
+
+@app.command("rm")
+def rm(
+    ids: List[int] = typer.Argument(..., help="File or folder ID(s) to delete"),
+    folder: bool = typer.Option(False, "--folder", "-f", help="IDs are folder IDs"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """Delete files or folders."""
+    client = _client()
+    kind = "folder" if folder else "file"
+
+    if not yes:
+        confirm = typer.confirm(
+            f"Delete {len(ids)} {kind}(s)? This cannot be undone.", default=False
+        )
+        if not confirm:
+            raise typer.Abort()
+
+    for item_id in ids:
+        try:
+            if folder:
+                result = client.post(f"/delete_folder/{item_id}")
+            else:
+                result = client.post(f"/delete/{item_id}")
+            if result.get("success"):
+                console.print(f"[green][/] {kind.capitalize()} {item_id} deleted.")
+            else:
+                console.print(f"[red]-[/] {result.get('message', 'Error')}")
+        except APIError as e:
+            console.print(f"[red]-[/] ID {item_id}: {e}")
+
+
+# ------------------------------------------------------------------ #
+# rename
+# ------------------------------------------------------------------ #
+
+@app.command("rename")
+def rename(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    new_name: str = typer.Argument(..., help="New name"),
+    folder: bool = typer.Option(False, "--folder", "-f", help="ID is a folder"),
+):
+    """Rename a file or folder."""
+    client = _client()
+    try:
+        if folder:
+            result = client.post(f"/rename_folder/{item_id}", json={"name": new_name})
+        else:
+            result = client.post(f"/rename/{item_id}", json={"filename": new_name})
+        if result.get("success"):
+            console.print(f"[green][/] Renamed to [bold]{new_name}[/bold].")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# mv
+# ------------------------------------------------------------------ #
+
+@app.command("mv")
+def mv(
+    item_id: int = typer.Argument(..., help="File or folder ID to move"),
+    dest_folder_id: int = typer.Argument(..., help="Destination folder ID"),
+    folder: bool = typer.Option(False, "--folder", "-f", help="ID is a folder"),
+):
+    """Move a file or folder to a different folder."""
+    client = _client()
+    try:
+
        if folder:
+            result = client.post("/api/move_folder", json={
+                "folder_id": item_id,
+                "new_parent_id": dest_folder_id,
+            })
+        else:
+            result = client.post("/api/move_file", json={
+                "file_id": item_id,
+                "destination_folder_id": dest_folder_id,
+            })
+        if result.get("success"):
+            console.print(f"[green][OK][/] Moved to folder {dest_folder_id}.")
+        else:
+            console.print(f"[red]-[/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+# ------------------------------------------------------------------ #
+# info
+# ------------------------------------------------------------------ #
+
+@app.command("info")
+def info(
+    file_id: int = typer.Argument(..., help="File ID"),
+):
+    """Show detailed metadata for a file."""
+    client = _client()
+    try:
+        data = client.get(f"/file_details/{file_id}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    f = data.get("file") or data
+    stashed = "[yellow]Yes[/]" if f.get("is_stashed") else "[dim]No[/]"
+    favorited = "[red]*[/]" if f.get("is_favorite") else "[dim]No[/]"
+    shared = "[cyan]Yes[/]" if f.get("is_shared") else "[dim]No[/]"
+    storage = f.get("storage_mode") or "central"
+    folder = f.get("folder_name") or (f"ID {f.get('folder_id')}" if f.get("folder_id") else "root")
+
+    console.print(Panel(
+        f"[bold]{f.get('original_filename', '?')}[/bold]\n\n"
+        f"[dim]ID:[/dim]           {f.get('id', '?')}\n"
+        f"[dim]Size:[/dim]         {fmt_size(f.get('file_size') or f.get('size'))}\n"
+        f"[dim]Uploaded:[/dim]     {str(f.get('upload_date') or f.get('created_at', '?'))[:19]}\n"
+
+        f"[dim]Uploaded:[/dim]     {str(f.get('upload_date') or f.get('created_at', '?'))[:19]}\n"
+        f"[dim]Folder:[/dim]       {folder}\n"
+        f"[dim]Storage node:[/dim] {storage}\n"
+        f"[dim]Stashed:[/dim]      {stashed}\n"
+        f"[dim]Favorite:[/dim]     {favorited}\n"
+        f"[dim]Shared:[/dim]       {shared}",
+        title="[bold]File Info[/bold]",
+        border_style="cyan",
+    ))
+
+
+@app.command("favorite")
+def favorite(
+    file_id: int = typer.Argument(..., help="File ID"),
+):
+    """Toggle favorite status for a file."""
+    client = _client()
+    try:
+        result = client.post(f"/api/files/{file_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} file {file_id}.")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+
+
+@app.command("cat")
+def cat(
+    file_id: int = typer.Argument(..., help="File ID to print"),
+):
+    """Print the raw contents of a file to the console."""
+    client = _client()
+    try:
+        raw_text = client.get_raw(f"/api/raw/{file_id}")
+        console.print(raw_text, end="")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("download-all")
+def download_all(
+    dest: Path = typer.Option(Path.cwd(), "--dest", "-d", help="Destination folder"),
+    node: str = typer.Option("central", "--node", "-n", help="Storage node to filter by (or 'all')"),
+):
+    """Download all files as a ZIP archive."""
+    client = _client()
+    if not dest.exists():
+        dest.mkdir(parents=True)
+    if not dest.is_dir():
+        console.print(f"[red]Destination is not a directory:[/] {dest}")
+        raise typer.Exit(1)
+
+    console.print("[cyan]Preparing download for all files...[/cyan]")
+    try:
+        path = client.download_all(dest_dir=dest, node=node)
+        console.print(f"[green][OK][/] Saved to {path.name}")
+    except APIError as e:
+        console.print(f"[red]-[/] Download failed: {e}")
+        raise typer.Exit(1)
+
+
+@app.command("rm-all")
+def remove_all(
+    confirm: bool = typer.Option(False, "--yes", "-y", help="Confirm deletion without prompting"),
+    node: str = typer.Option("all", "--node", "-n", help="Storage node to wipe (or 'all')"),
+):
+    """Delete all files in your account."""
+    if not confirm:
+        sure = Prompt.ask(f"[bold red]Are you absolutely sure you want to delete ALL files on node '{node}'? This cannot be undone[/bold red] (y/N)")
+        if sure.lower() not in ('y', 'yes'):
+            console.print("Bulk deletion aborted.")
+            raise typer.Exit()
+            
+    client = _client()
+    try:
+        result = client.post("/delete_all_files", json={"target_node": node})
+        if result.get("success"):
+            console.print(f"[green][OK][/] {result.get('message', 'All files deleted.')}")
+        else:
+            console.print(f"[red]-[/] {result.get('error', 'Error deleting files.')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")