kctl-opencloud 0.5.0__py3-none-any.whl

kctl_opencloud/commands/health.py

@@ -0,0 +1,135 @@
+"""Health check commands for kctl-opencloud."""
+
+from __future__ import annotations
+
+import time
+from typing import Annotated, Any
+
+import httpx
+import typer
+
+from kctl_opencloud.core.callbacks import AppContext
+
+app = typer.Typer(help="Health checks and monitoring.")
+
+
+def _check_endpoint(base_url: str, path: str) -> int:
+    """Check an endpoint, return HTTP status code."""
+    try:
+        r = httpx.get(f"{base_url}{path}", timeout=5, follow_redirects=True)
+        return r.status_code
+    except httpx.HTTPError:
+        return 0
+
+
+def _run_health_check(c: AppContext) -> dict[str, Any]:
+    """Run all health checks and return results."""
+    base_url = c.client.root_url
+    score = 0
+    checks: dict[str, str] = {}
+
+    # OCS capabilities (30 pts)
+    status = _check_endpoint(base_url, "/ocs/v1.php/cloud/capabilities")
+    if status == 200:
+        score += 30
+        checks["ocs"] = "ok"
+    else:
+        checks["ocs"] = "fail"
+
+    # Web UI (20 pts)
+    status = _check_endpoint(base_url, "/")
+    if status in (200, 302):
+        score += 20
+        checks["web"] = "ok"
+    else:
+        checks["web"] = "fail"
+
+    # Graph API (20 pts)
+    status = _check_endpoint(base_url, "/graph/v1.0/me")
+    if status in (200, 401):
+        score += 20
+        checks["graph"] = "ok"
+    else:
+        checks["graph"] = "fail"
+
+    # WebDAV (15 pts)
+    status = _check_endpoint(base_url, "/remote.php/dav/")
+    if status in (200, 401, 207):
+        score += 15
+        checks["dav"] = "ok"
+    else:
+        checks["dav"] = "fail"
+
+    # OIDC discovery (15 pts)
+    status = _check_endpoint(base_url, "/.well-known/openid-configuration")
+    if status in (200, 301, 302):
+        score += 15
+        checks["oidc"] = "ok"
+    else:
+        checks["oidc"] = "fail"
+
+    overall = "healthy" if score >= 80 else "degraded" if score >= 50 else "unhealthy"
+
+    return {"score": score, "status": overall, "checks": checks, "url": base_url}
+
+
+def _display_health(c: AppContext, result: dict[str, Any]) -> None:
+    """Display health check results."""
+    out = c.output
+
+    if c.json_mode:
+        out.raw_json(result)
+        return
+
+    out.header("OpenCloud Health Check")
+    out.kv("URL", result["url"])
+
+    check_labels = {
+        "ocs": ("OCS capabilities", 30),
+        "web": ("Web UI reachable", 20),
+        "graph": ("Graph API", 20),
+        "dav": ("WebDAV", 15),
+        "oidc": ("OIDC discovery", 15),
+    }
+
+    for key, (label, pts) in check_labels.items():
+        status = result["checks"][key]
+        if status == "ok":
+            out.success(f"{label} ({pts} pts)")
+        else:
+            out.error(f"{label} (0/{pts} pts)")
+
+    score = result["score"]
+    overall = result["status"]
+    if overall == "healthy":
+        out.success(f"Score: {score}/100 — Healthy")
+    elif overall == "degraded":
+        out.warn(f"Score: {score}/100 — Degraded")
+    else:
+        out.error(f"Score: {score}/100 — Unhealthy")
+
+
+@app.callback(invoke_without_command=True)
+def check(
+    ctx: typer.Context,
+    watch: Annotated[bool, typer.Option("--watch", "-w", help="Continuous monitoring")] = False,
+    interval: Annotated[int, typer.Option("--interval", "-i", help="Watch interval in seconds")] = 10,
+) -> None:
+    """Run health checks."""
+    c: AppContext = ctx.obj
+
+    if watch:
+        try:
+            while True:
+                result = _run_health_check(c)
+                _display_health(c, result)
+                time.sleep(interval)
+        except KeyboardInterrupt:
+            pass
+    else:
+        result = _run_health_check(c)
+        _display_health(c, result)
+        if result["score"] < 50:
+            raise typer.Exit(code=2)
+        elif result["score"] < 80:
+            raise typer.Exit(code=1)

kctl_opencloud/commands/shares.py

@@ -0,0 +1,109 @@
+"""Sharing and permission commands for kctl-opencloud."""
+
+# NOTE: Shares/permissions API uses the beta endpoint /graph/v1beta1.
+# Since API_PREFIX="/graph/v1.0", we use "../v1beta1/" to traverse one
+# segment up. This is verified to work with httpx URL resolution.
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import typer
+
+from kctl_opencloud.core.callbacks import AppContext
+
+app = typer.Typer(help="Sharing and permission management.")
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space/drive ID")],
+    item_id: Annotated[str, typer.Argument(help="Item (file/folder) ID")],
+) -> None:
+    """List permissions on a file or folder."""
+    c: AppContext = ctx.obj
+    # Use beta API for permissions
+    client = c.client
+    data = client.get(f"../v1beta1/drives/{space_id}/items/{item_id}/permissions")
+    permissions = data.get("value", []) if isinstance(data, dict) else []
+
+    rows = []
+    for p in permissions:
+        link = p.get("link", {})
+        granted = p.get("grantedToV2", {})
+        user = granted.get("user", {})
+        rows.append(
+            [
+                p.get("id", ""),
+                user.get("displayName", link.get("type", "-")),
+                ", ".join(p.get("roles", [])),
+                link.get("webUrl", "-"),
+            ]
+        )
+
+    c.output.table(
+        "Permissions",
+        [("ID", "cyan"), ("Granted To", "green"), ("Roles", "yellow"), ("Link", "white")],
+        rows,
+        data_for_json=permissions,
+    )
+
+
+@app.command("create-link")
+def create_link(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space/drive ID")],
+    item_id: Annotated[str, typer.Argument(help="Item ID")],
+    type_: Annotated[str, typer.Option("--type", "-t", help="Link type: view, edit")] = "view",
+    password: Annotated[str | None, typer.Option("--password", help="Link password")] = None,
+) -> None:
+    """Create a sharing link."""
+    c: AppContext = ctx.obj
+    link_data: dict[str, Any] = {
+        "type": type_,
+    }
+    if password:
+        link_data["password"] = password
+
+    result = c.client.post(
+        f"../v1beta1/drives/{space_id}/items/{item_id}/createLink",
+        data=link_data,
+    )
+    link_url = result.get("link", {}).get("webUrl", "")
+    c.output.success(f"Link created: {link_url}")
+
+
+@app.command()
+def invite(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space/drive ID")],
+    item_id: Annotated[str, typer.Argument(help="Item ID")],
+    user_id: Annotated[str, typer.Option("--user", "-u", help="User ID to invite")],
+    role: Annotated[str, typer.Option("--role", "-r", help="Role: viewer, editor")] = "viewer",
+) -> None:
+    """Invite a user to access a file or folder."""
+    c: AppContext = ctx.obj
+    invite_data: dict[str, Any] = {
+        "recipients": [{"objectId": user_id}],
+        "roles": [role],
+    }
+
+    c.client.post(
+        f"../v1beta1/drives/{space_id}/items/{item_id}/invite",
+        data=invite_data,
+    )
+    c.output.success(f"User {user_id} invited with role '{role}'")
+
+
+@app.command("delete")
+def delete_permission(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space/drive ID")],
+    item_id: Annotated[str, typer.Argument(help="Item ID")],
+    permission_id: Annotated[str, typer.Argument(help="Permission ID")],
+) -> None:
+    """Remove a permission from a file or folder."""
+    c: AppContext = ctx.obj
+    c.client.delete(f"../v1beta1/drives/{space_id}/items/{item_id}/permissions/{permission_id}")
+    c.output.success(f"Permission {permission_id} removed")

kctl_opencloud/commands/skill_cmd.py

@@ -0,0 +1,50 @@
+"""Skill generation command for kctl-opencloud."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+app = typer.Typer(help="Skill management.", hidden=True)
+
+
+@app.command()
+def generate(
+    ctx: typer.Context,
+    output: Annotated[str | None, typer.Option("--output", "-o", help="Output directory")] = None,
+    install: Annotated[bool, typer.Option("--install", help="Install to user skills dir")] = False,
+    check: Annotated[bool, typer.Option("--check", help="Check if skill is stale")] = False,
+) -> None:
+    """Generate Claude Code skill file."""
+    from kctl_lib.skill_generator import check_stale, generate_skill
+
+    from kctl_opencloud.cli import app as cli_app
+
+    skill_name = "opencloud-admin"
+
+    extra_path = Path(__file__).parent.parent.parent.parent / "skills" / skill_name / "SKILL.extra.md"
+    extra_content = extra_path.read_text() if extra_path.exists() else None
+
+    if check:
+        if check_stale(skill_name, cli_app, extra_content=extra_content):
+            typer.echo("Skill is stale — regenerate with: kctl-opencloud skill generate --install")
+            raise typer.Exit(code=1)
+        typer.echo("Skill is up to date")
+        return
+
+    if output:
+        out_dir = Path(output)
+    elif install:
+        out_dir = Path.home() / ".claude" / "skills" / skill_name
+    else:
+        out_dir = Path(__file__).parent.parent.parent.parent / "skills" / skill_name
+
+    generate_skill(
+        skill_name=skill_name,
+        cli_app=cli_app,
+        output_dir=out_dir,
+        extra_content=extra_content,
+    )
+    typer.echo(f"Skill generated at {out_dir}/SKILL.md")

kctl_opencloud/commands/spaces.py

@@ -0,0 +1,173 @@
+"""Space/drive management commands for kctl-opencloud."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import typer
+
+from kctl_opencloud.core.callbacks import AppContext
+
+app = typer.Typer(help="Drive and space management.")
+
+
+def _format_bytes(size: float) -> str:
+    """Format bytes to human readable."""
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} PB"
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    type_filter: Annotated[str | None, typer.Option("--type", "-t", help="Filter by type (personal, project)")] = None,
+) -> None:
+    """List all spaces/drives."""
+    c: AppContext = ctx.obj
+    spaces = c.client.get_all("drives")
+
+    if type_filter:
+        spaces = [s for s in spaces if s.get("driveType") == type_filter]
+
+    rows = []
+    for s in spaces:
+        quota = s.get("quota", {})
+        used = quota.get("used", 0)
+        total = quota.get("total", 0)
+        rows.append(
+            [
+                s.get("id", ""),
+                s.get("name", "-"),
+                s.get("driveType", "-"),
+                _format_bytes(used),
+                _format_bytes(total) if total > 0 else "unlimited",
+            ]
+        )
+
+    c.output.table(
+        "Spaces",
+        [("ID", "cyan"), ("Name", "green"), ("Type", "yellow"), ("Used", "white"), ("Quota", "white")],
+        rows,
+        data_for_json=spaces,
+    )
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space/drive ID")],
+) -> None:
+    """Get space details."""
+    c: AppContext = ctx.obj
+    space = c.client.get(f"drives/{space_id}")
+
+    quota = space.get("quota", {})
+    sections = [
+        (
+            "Space",
+            [
+                ("ID", space.get("id", "")),
+                ("Name", space.get("name", "-")),
+                ("Type", space.get("driveType", "-")),
+                ("Description", space.get("description", "-")),
+                ("Used", _format_bytes(quota.get("used", 0))),
+                ("Total", _format_bytes(quota.get("total", 0)) if quota.get("total", 0) > 0 else "unlimited"),
+                ("State", space.get("root", {}).get("deleted", {}).get("state", "active")),
+            ],
+        ),
+    ]
+    c.output.detail("Space Details", sections, data_for_json=space)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Space name")],
+    description: Annotated[str, typer.Option("--description", "-d", help="Space description")] = "",
+    quota: Annotated[int | None, typer.Option("--quota", "-q", help="Quota in bytes")] = None,
+) -> None:
+    """Create a project space."""
+    c: AppContext = ctx.obj
+    space_data: dict[str, Any] = {
+        "name": name,
+        "driveType": "project",
+    }
+    if description:
+        space_data["description"] = description
+    if quota is not None:
+        space_data["quota"] = {"total": quota}
+
+    space = c.client.post("drives", data=space_data)
+    c.output.success(f"Space created: {space.get('name', name)}")
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space ID")],
+    name: Annotated[str | None, typer.Option("--name", "-n", help="New name")] = None,
+    description: Annotated[str | None, typer.Option("--description", "-d", help="New description")] = None,
+    quota_val: Annotated[int | None, typer.Option("--quota", "-q", help="New quota in bytes")] = None,
+) -> None:
+    """Update a space."""
+    c: AppContext = ctx.obj
+    patch_data: dict[str, Any] = {}
+    if name is not None:
+        patch_data["name"] = name
+    if description is not None:
+        patch_data["description"] = description
+    if quota_val is not None:
+        patch_data["quota"] = {"total": quota_val}
+
+    if not patch_data:
+        c.output.warn("No changes specified")
+        return
+
+    c.client.patch(f"drives/{space_id}", data=patch_data)
+    c.output.success(f"Space {space_id} updated")
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space ID")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation")] = False,
+) -> None:
+    """Delete a space."""
+    c: AppContext = ctx.obj
+    if not force:
+        typer.confirm(f"Delete space {space_id}?", abort=True)
+    c.client.delete(f"drives/{space_id}")
+    c.output.success(f"Space {space_id} deleted")
+
+
+@app.command("quota")
+def quota_cmd(
+    ctx: typer.Context,
+    space_id: Annotated[str, typer.Argument(help="Space ID")],
+) -> None:
+    """Show space quota usage."""
+    c: AppContext = ctx.obj
+    space = c.client.get(f"drives/{space_id}")
+    q = space.get("quota", {})
+
+    used = q.get("used", 0)
+    total = q.get("total", 0)
+    remaining = q.get("remaining", total - used if total > 0 else 0)
+
+    sections = [
+        (
+            "Quota",
+            [
+                ("Space", space.get("name", space_id)),
+                ("Used", _format_bytes(used)),
+                ("Total", _format_bytes(total) if total > 0 else "unlimited"),
+                ("Remaining", _format_bytes(remaining) if total > 0 else "unlimited"),
+                ("Usage", f"{(used / total * 100):.1f}%" if total > 0 else "N/A"),
+            ],
+        ),
+    ]
+    c.output.detail("Space Quota", sections, data_for_json=q)

kctl_opencloud/commands/users.py

@@ -0,0 +1,133 @@
+"""User management commands for kctl-opencloud."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+import typer
+
+from kctl_opencloud.core.callbacks import AppContext
+
+app = typer.Typer(help="User management.")
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    search: Annotated[str | None, typer.Option("--search", "-s", help="Search by name or email")] = None,
+) -> None:
+    """List all users."""
+    c: AppContext = ctx.obj
+    params: dict[str, Any] = {}
+    if search:
+        params["$search"] = search
+
+    users = c.client.get_all("users", params=params)
+
+    rows = []
+    for u in users:
+        rows.append(
+            [
+                u.get("id", ""),
+                u.get("displayName", "-"),
+                u.get("mail", "-"),
+                "active" if u.get("accountEnabled", True) else "disabled",
+            ]
+        )
+
+    c.output.table(
+        "Users",
+        [("ID", "cyan"), ("Name", "green"), ("Email", "white"), ("Status", "yellow")],
+        rows,
+        data_for_json=users,
+    )
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    user_id: Annotated[str, typer.Argument(help="User ID")],
+) -> None:
+    """Get user details."""
+    c: AppContext = ctx.obj
+    user = c.client.get(f"users/{user_id}")
+
+    sections = [
+        (
+            "User",
+            [
+                ("ID", user.get("id", "")),
+                ("Display Name", user.get("displayName", "-")),
+                ("Email", user.get("mail", "-")),
+                ("Username", user.get("onPremisesSamAccountName", "-")),
+                ("Enabled", str(user.get("accountEnabled", True))),
+            ],
+        ),
+    ]
+    c.output.detail("User Details", sections, data_for_json=user)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    email: Annotated[str, typer.Argument(help="User email address")],
+    name: Annotated[str | None, typer.Option("--name", "-n", help="Display name")] = None,
+    password: Annotated[str | None, typer.Option("--password", help="Initial password")] = None,
+) -> None:
+    """Create a new user."""
+    c: AppContext = ctx.obj
+    display_name = name or email.split("@")[0]
+    username = email.split("@")[0]
+
+    user_data: dict[str, Any] = {
+        "displayName": display_name,
+        "mail": email,
+        "onPremisesSamAccountName": username,
+        "accountEnabled": True,
+    }
+    if password:
+        user_data["passwordProfile"] = {"password": password}
+
+    user = c.client.post("users", data=user_data)
+    c.output.success(f"User created: {user.get('displayName', email)}")
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    user_id: Annotated[str, typer.Argument(help="User ID")],
+    name: Annotated[str | None, typer.Option("--name", "-n", help="Display name")] = None,
+    email: Annotated[str | None, typer.Option("--email", help="Email address")] = None,
+    enabled: Annotated[bool | None, typer.Option("--enabled/--disabled", help="Account status")] = None,
+) -> None:
+    """Update a user."""
+    c: AppContext = ctx.obj
+    patch_data: dict[str, Any] = {}
+    if name is not None:
+        patch_data["displayName"] = name
+    if email is not None:
+        patch_data["mail"] = email
+    if enabled is not None:
+        patch_data["accountEnabled"] = enabled
+
+    if not patch_data:
+        c.output.warn("No changes specified")
+        return
+
+    c.client.patch(f"users/{user_id}", data=patch_data)
+    c.output.success(f"User {user_id} updated")
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    user_id: Annotated[str, typer.Argument(help="User ID")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation")] = False,
+) -> None:
+    """Delete a user."""
+    c: AppContext = ctx.obj
+    if not force:
+        typer.confirm(f"Delete user {user_id}?", abort=True)
+
+    c.client.delete(f"users/{user_id}")
+    c.output.success(f"User {user_id} deleted")

kctl_opencloud/core/callbacks.py

@@ -0,0 +1,34 @@
+"""Typer global callback and shared context for kctl-opencloud.
+
+Subclasses AppContextBase from kctl-lib, adding OpenCloud-specific
+client resolution.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from kctl_lib.callbacks import AppContextBase
+
+from kctl_opencloud.core.client import OpenCloudClient
+from kctl_opencloud.core.config import resolve_connection
+
+
+@dataclass
+class AppContext(AppContextBase):
+    """OpenCloud-specific application context."""
+
+    url_override: str | None = None
+    token_override: str | None = None
+    _client: OpenCloudClient | None = field(default=None, repr=False)
+
+    @property
+    def client(self) -> OpenCloudClient:
+        if self._client is None:
+            url, token = resolve_connection(
+                profile_name=self.profile,
+                url_override=self.url_override,
+                token_override=self.token_override,
+            )
+            self._client = OpenCloudClient(base_url=url, credential=token)
+        return self._client