mycloudctl 1.0.0__py3-none-any.whl

cli/commands/share.py

@@ -0,0 +1,392 @@
+"""commands/share.py -- share, unshare, shared-with-me, accept, decline, link, copy, mute."""
+from __future__ import annotations
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from cli.api import CloudClient, APIError
+from cli.ui.table import shares_table
+
+app = typer.Typer(help="Sharing -- share files/folders, manage invites and public links.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+# ------------------------------------------------------------------ #
+# send (invite)
+# ------------------------------------------------------------------ #
+
+@app.command("send")
+def share_send(
+    item_id: int = typer.Argument(..., help="File or folder ID to share"),
+    user: str = typer.Option(..., "--user", "-u", help="Username or email of recipient"),
+    folder: bool = typer.Option(False, "--folder", "-f", help="ID is a folder"),
+    permission: str = typer.Option("read", "--permission", "-p", help="read | write"),
+):
+    """Share a file or folder with another user."""
+    client = _client()
+    try:
+        if folder:
+            result = client.post(f"/share_folder/{item_id}", json={"shared_with": user, "permission": permission})
+        else:
+            result = client.post(f"/share_file/{item_id}", json={"shared_with": user, "permission": permission})
+        if result.get("success"):
+            console.print(f"[green][OK][/] Shared with [bold]{user}[/bold] ({permission}).")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message') or 'Error'}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# link (public link)
+# ------------------------------------------------------------------ #
+
+@app.command("link")
+def share_link(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    folder: bool = typer.Option(False, "--folder", "-f", help="ID is a folder"),
+):
+    """Generate a public share link for a file or folder."""
+    client = _client()
+    try:
+        if folder:
+            result = client.post(f"/generate_folder_share_link/{item_id}")
+        else:
+            result = client.post(f"/generate_share_link/{item_id}")
+        link = result.get("link") or result.get("share_link") or result.get("url") or result.get("share_url")
+        if link:
+            console.print(f"[green][OK][/] Share link:\n[bold cyan]{link}[/bold cyan]")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Could not generate link')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# disable-link
+# ------------------------------------------------------------------ #
+
+@app.command("disable-link")
+def share_disable_link(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    item_type: str = typer.Option("file", "--type", "-t", help="'file' or 'folder'"),
+):
+    """Disable/revoke the public share link for a file or folder."""
+    client = _client()
+    try:
+        result = client.post("/api/share/disable_link", json={"item_id": item_id, "item_type": item_type})
+        if result.get("success"):
+            console.print("[green][OK][/] Share link disabled.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# info
+# ------------------------------------------------------------------ #
+
+@app.command("info")
+def share_info(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    item_type: str = typer.Option("file", "--type", "-t", help="'file' or 'folder'"),
+):
+    """Show share details for a file or folder."""
+    client = _client()
+    try:
+        result = client.get(f"/api/share_details/{item_type}/{item_id}")
+        rows = result.get("shares", []) or result.get("data", [])
+        if not rows:
+            console.print("[dim]Not shared with anyone.[/dim]")
+            return
+        console.print(shares_table(rows))
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# update-perm
+# ------------------------------------------------------------------ #
+
+@app.command("update-perm")
+def share_update_perm(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    user_id: int = typer.Option(..., "--user-id", help="User ID whose permission to change"),
+    permission: str = typer.Option(..., "--permission", "-p", help="read | write"),
+    item_type: str = typer.Option("file", "--type", "-t", help="'file' or 'folder'"),
+):
+    """Update a share's permission level."""
+    client = _client()
+    try:
+        result = client.post("/api/share/update_permissions", json={
+            "item_id": item_id,
+            "item_type": item_type,
+            "shared_with_user_id": user_id,
+            "permission": permission,
+        })
+        if result.get("success"):
+            console.print(f"[green][OK][/] Permission updated to '{permission}'.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# rm (remove share)
+# ------------------------------------------------------------------ #
+
+@app.command("rm")
+def share_rm(
+    item_id: int = typer.Argument(..., help="File or folder ID"),
+    item_type: str = typer.Option("file", "--type", "-t", help="'file' or 'folder'"),
+    shared_with_id: Optional[int] = typer.Option(None, "--with-id", help="Specific user ID to un-share"),
+):
+    """Remove a share from a file or folder."""
+    client = _client()
+    try:
+        result = client.post("/api/share/remove", json={
+            "item_type": item_type,
+            "item_id": item_id,
+            "shared_with_user_id": shared_with_id,
+        })
+        if result.get("success"):
+            console.print("[green][OK][/] Share removed.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# copy (add shared file to my cloud)
+# ------------------------------------------------------------------ #
+
+@app.command("copy")
+def share_copy(
+    file_id: int = typer.Argument(..., help="Shared file ID to copy to your cloud"),
+):
+    """Copy a shared file into your own myCloud storage."""
+    client = _client()
+    try:
+        result = client.post(f"/add_shared_to_mycloud/{file_id}")
+        if result.get("success"):
+            console.print(f"[green][OK][/] {result.get('message', 'File copied to your cloud.')}")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# copy-folder (add shared folder to my cloud)
+# ------------------------------------------------------------------ #
+
+@app.command("copy-folder")
+def share_copy_folder(
+    folder_id: int = typer.Argument(..., help="Shared folder ID to copy to your cloud"),
+):
+    """Copy a shared folder (and contents) into your own myCloud storage."""
+    client = _client()
+    try:
+        result = client.post(f"/copy_shared_folder/{folder_id}")
+        if result.get("success"):
+            console.print(f"[green][OK][/] {result.get('message', 'Folder copied to your cloud.')}")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# with-me
+# ------------------------------------------------------------------ #
+
+@app.command("with-me")
+def shared_with_me():
+    """List all files and folders shared with you."""
+    client = _client()
+    try:
+        data = client.get("/shared_files")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    files = data.get("shared_files", []) or data.get("files", [])
+    folders = data.get("shared_folders", []) or data.get("folders", [])
+
+    from cli.ui.table import files_table, folders_table
+    if folders:
+        console.print(folders_table(folders, title="Folders Shared With Me"))
+    if files:
+        console.print(files_table(files, title="Files Shared With Me"))
+    if not files and not folders:
+        console.print("[dim]Nothing shared with you yet.[/dim]")
+
+
+# ------------------------------------------------------------------ #
+# Invites -- list / accept / decline
+# ------------------------------------------------------------------ #
+
+@app.command("invites")
+def share_invites():
+    """List pending share invites."""
+    client = _client()
+    try:
+        result = client.get("/api/share_invites/details")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    invites = result.get("invites", []) or result.get("data", [])
+    if not invites:
+        console.print("[dim]No pending share invites.[/dim]")
+        return
+
+    t = Table(title="Pending Share Invites", box=box.ROUNDED, header_style="bold cyan")
+    t.add_column("Token", style="dim", no_wrap=True)
+    t.add_column("From")
+    t.add_column("Item")
+    t.add_column("Type")
+
+    for inv in invites:
+        t.add_row(
+            inv.get("request_token") or inv.get("token") or "-",
+            inv.get("sender_username") or inv.get("sender_email") or "?",
+            str(inv.get("item_id", "?")),
+            inv.get("item_type", "?"),
+        )
+    console.print(t)
+
+
+@app.command("accept")
+def share_accept(
+    token: str = typer.Argument(..., help="Share invite token"),
+):
+    """Accept a share invite."""
+    client = _client()
+    try:
+        result = client.post("/api/share_invites/respond", json={"token": token, "action": "accept"})
+        if result.get("success"):
+            console.print("[green][OK][/] Invite accepted.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("decline")
+def share_decline(
+    token: str = typer.Argument(..., help="Share invite token"),
+):
+    """Decline a share invite."""
+    client = _client()
+    try:
+        result = client.post("/api/share_invites/respond", json={"token": token, "action": "decline"})
+        if result.get("success"):
+            console.print("[green][OK][/] Invite declined.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+# ------------------------------------------------------------------ #
+# Mute / unmute senders
+# ------------------------------------------------------------------ #
+
+@app.command("mute")
+def share_mute(
+    identifier: str = typer.Argument(..., help="Username or email to mute share invites from"),
+):
+    """Mute share invites from a user."""
+    client = _client()
+    try:
+        result = client.post("/api/share_invites/mute", json={"identifier": identifier})
+        if result.get("success"):
+            console.print(f"[green][OK][/] Muted share invites from {identifier}.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("unmute")
+def share_unmute(
+    muted_user_id: int = typer.Argument(..., help="User ID to unmute"),
+):
+    """Unmute share invites from a user."""
+    client = _client()
+    try:
+        result = client.post("/api/share_invites/unmute", json={"muted_user_id": muted_user_id})
+        if result.get("success"):
+            console.print(f"[green][OK][/] Unmuted user {muted_user_id}.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+
+
+@app.command("muted")
+def share_muted():
+    """List users whose share invites you have muted."""
+    client = _client()
+    try:
+        result = client.get("/api/share_invites/muted_users")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    users = result.get("muted_users") or result.get("data", [])
+    if not users:
+        console.print("[dim]No muted users.[/dim]")
+        return
+
+    t = Table(title="Muted Users", box=box.ROUNDED, header_style="bold yellow")
+    t.add_column("User ID", style="dim", justify="right")
+    t.add_column("Username")
+    for u in users:
+        t.add_row(str(u.get("id", "?")), u.get("username") or u.get("email") or "?")
+    console.print(t)
+
+
+@app.command("claim-link")
+def share_claim_link(
+    token: str = typer.Argument(..., help="Public share token to claim"),
+):
+    """Claim a public share link using its token."""
+    client = _client()
+    endpoints = [
+        "/add_share_from_token",
+        "/add_folder_share_from_token",
+        "/add_batch_share_from_token"
+    ]
+    
+    success = False
+    errors = []
+    
+    for endpoint in endpoints:
+        try:
+            result = client.post(endpoint, json={"token": token})
+            if result.get("success"):
+                console.print(f"[green][OK][/] {result.get('message', 'Share link claimed successfully.')}")
+                success = True
+                break
+        except APIError as e:
+            msg = str(e)
+            if "Invalid or expired" not in msg:
+                errors.append(msg)
+            
+    if not success:
+        if errors:
+            console.print(f"[red][FAIL][/] {errors[0]}")
+        else:
+            console.print("[red][FAIL][/] Token is invalid or expired.")

cli/commands/stash.py

@@ -0,0 +1,92 @@
+"""commands/stash.py  stash add, ls, pop commands."""
+from __future__ import annotations
+from typing import List, 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="Stash  temporary file storage with auto-expiry.")
+console = Console()
+
+
+def _client() -> CloudClient:
+    return CloudClient()
+
+
+@app.command("ls")
+def stash_ls():
+    """List your stashed files."""
+    client = _client()
+    try:
+        data = client.get("/stash_page")
+    except APIError as e:
+        console.print(f"[red]-[/] {e}")
+        raise typer.Exit(1)
+
+    files = data.get("stashed_files", []) or data.get("files", [])
+    if not files:
+        console.print("[dim]No stashed files.[/dim]")
+        return
+
+    t = Table(title="Stashed Files", box=box.ROUNDED, header_style="bold yellow")
+    t.add_column("ID", justify="right", style="dim")
+    t.add_column("Name")
+    t.add_column("Size", justify="right", style="green")
+    t.add_column("Expires", style="dim")
+
+    for f in files:
+        t.add_row(
+            str(f.get("id", "?")),
+            f.get("filename") or f.get("name") or f.get("original_filename") or "-",
+            _fmt(f.get("size") or f.get("file_size") or 0),
+            str(f.get("stash_expiry_at") or "")[:16],
+        )
+    console.print(t)
+
+
+@app.command("add")
+def stash_add(
+    file_ids: List[int] = typer.Argument(..., help="File ID(s) to stash"),
+    days: int = typer.Option(7, "--days", "-d", help="Expiry in days"),
+):
+    """Move file(s) to the stash (temporary storage with expiry)."""
+    client = _client()
+    for fid in file_ids:
+        try:
+            result = client.post("/api/batch_stash", json={"file_ids": [fid], "days": days})
+            if result.get("success"):
+                console.print(f"[green][OK][/] File {fid} stashed for {days} day(s).")
+            else:
+                console.print(f"[red][FAIL][/] File {fid}: {result.get('message', 'Error')}")
+        except APIError as e:
+            console.print(f"[red]-[/] File {fid}: {e}")
+
+
+@app.command("pop")
+def stash_pop(
+    file_ids: List[int] = typer.Argument(..., help="File ID(s) to unstash"),
+):
+    """Restore file(s) from the stash back to your storage."""
+    client = _client()
+    for fid in file_ids:
+        try:
+            result = client.post("/api/batch_unstash", json={"file_ids": [fid]})
+            if result.get("success"):
+                console.print(f"[green][OK][/] File {fid} restored from stash.")
+            else:
+                console.print(f"[red][FAIL][/] File {fid}: {result.get('message', 'Error')}")
+        except APIError as e:
+            console.print(f"[red]-[/] File {fid}: {e}")
+
+
+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/storage.py

@@ -0,0 +1,88 @@
+"""commands/storage.py -- storage stats and nuke commands."""
+from __future__ import annotations
+
+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="Storage -- view stats and manage your storage quota.")
+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("stats")
+def stats():
+    """Show your storage usage and account statistics."""
+    client = _client()
+    try:
+        data = client.get("/api/user/stats")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")
+        raise typer.Exit(1)
+
+    used = int(data.get("storage_used") or 0)
+    total = int(data.get("storage_limit") or 0)
+    limit_label = data.get("storage_limit_label") or (_fmt(total) if total else "Unlimited")
+    files = int(data.get("file_count") or 0)
+    folders = int(data.get("folder_count") or 0)
+    stashed = int(data.get("stash_count") or 0)
+    shared = int(data.get("shared_count") or 0)
+
+    pct = f"{(used / total * 100):.1f}%" if total else "N/A"
+
+    bar_width = 30
+    filled = int((used / total) * bar_width) if total else 0
+    bar = "[green]" + "#" * filled + "[/][dim]" + "-" * (bar_width - filled) + "[/]"
+
+    console.print(Panel(
+        f"[bold]Storage Used:[/bold]  {_fmt(used)} / {limit_label}  ({pct})\n"
+        f"{bar}\n\n"
+        f"[dim]Files:[/dim]    {files}\n"
+        f"[dim]Folders:[/dim]  {folders}\n"
+        f"[dim]Stashed:[/dim]  {stashed}\n"
+        f"[dim]Shared:[/dim]   {shared}",
+        title="[bold cyan]myCloud Storage[/bold cyan]",
+        border_style="cyan",
+    ))
+
+
+@app.command("nuke")
+def nuke(
+    target: str = typer.Option("all", "--target", "-t",
+        help="What to delete: 'all', 'central', or a node ID"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+):
+    """[DANGER] Delete ALL files and folders. Cannot be undone."""
+    if not yes:
+        console.print("[bold red][WARN] This will permanently delete ALL your files and folders![/]")
+        typer.confirm("Are you absolutely sure?", abort=True)
+        typer.confirm("This CANNOT be undone. Proceed?", abort=True)
+
+    client = _client()
+    try:
+        result = client.post("/delete_all_files", data={"target_node": target})
+        if result.get("success"):
+            console.print("[green][OK][/] All files and folders deleted.")
+        else:
+            console.print(f"[red][FAIL][/] {result.get('message', 'Error')}")
+    except APIError as e:
+        console.print(f"[red][FAIL][/] {e}")

cli/config.py

@@ -0,0 +1,87 @@
+"""
+config.py  myCloud CLI configuration and credential management.
+
+Credentials are stored in ~/.mycloud/credentials.json.
+The server base URL is read from:
+  1. $MYCLOUD_URL environment variable
+  2. ~/.mycloud/config.toml  [url = "https://..."]
+  3. Falls back to the default production URL.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+CONFIG_DIR = Path.home() / ".mycloud"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials.json"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+
+DEFAULT_URL = "https://cloud.mysphere.co.in"
+
+
+def get_base_url() -> str:
+    """Return the server base URL (trailing slash stripped)."""
+    # 1. Environment variable
+    env = os.environ.get("MYCLOUD_URL", "").strip()
+    if env:
+        return env.rstrip("/")
+
+    # 2. Try credentials.json first since `login` saves it there
+    creds = load_credentials()
+    if creds.get("base_url"):
+        return creds["base_url"].rstrip("/")
+
+    # 3. Config file (minimal TOML  just look for `url = "..."`)
+    if CONFIG_FILE.exists():
+        for line in CONFIG_FILE.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line.startswith("url") and "=" in line:
+                value = line.split("=", 1)[1].strip().strip('"').strip("'")
+                if value:
+                    return value.rstrip("/")
+
+    return DEFAULT_URL
+
+
+# ---------------------------------------------------------------------------
+# Credentials
+# ---------------------------------------------------------------------------
+
+def load_credentials() -> dict:
+    """Return stored credentials dict or empty dict."""
+    if CREDENTIALS_FILE.exists():
+        try:
+            return json.loads(CREDENTIALS_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            return {}
+    return {}
+
+
+def save_credentials(data: dict) -> None:
+    """Persist credentials to disk (mode 600)."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CREDENTIALS_FILE.write_text(json.dumps(data, indent=2), encoding="utf-8")
+    try:
+        CREDENTIALS_FILE.chmod(0o600)
+    except Exception:
+        pass
+
+
+def clear_credentials() -> None:
+    """Delete stored credentials."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+
+
+def get_token() -> str:
+    """Return the stored bearer token, or empty string."""
+    return load_credentials().get("token", "")
+
+
+def get_stored_user() -> dict:
+    """Return the stored user info dict."""
+    return load_credentials().get("user", {})

cli/ui/__init__.py

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