kctl-opencloud 0.5.0__py3-none-any.whl

kctl_opencloud/__init__.py

@@ -0,0 +1,3 @@
+"""kctl-opencloud: Kodemeio OpenCloud CLI."""
+
+__version__ = "0.5.0"

kctl_opencloud/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m kctl_opencloud."""
+
+from kctl_opencloud.cli import app
+
+app()

kctl_opencloud/cli.py

@@ -0,0 +1,124 @@
+"""Main CLI entry point for kctl-opencloud."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from kctl_lib import KctlError, handle_cli_error
+
+from kctl_opencloud import __version__
+from kctl_opencloud.commands.config_cmd import app as config_app
+from kctl_opencloud.commands.dashboard import app as dashboard_app
+from kctl_opencloud.commands.doctor_cmd import app as doctor_app
+from kctl_opencloud.commands.groups import app as groups_app
+from kctl_opencloud.commands.health import app as health_app
+from kctl_opencloud.commands.shares import app as shares_app
+from kctl_opencloud.commands.skill_cmd import app as skill_app
+from kctl_opencloud.commands.spaces import app as spaces_app
+from kctl_opencloud.commands.users import app as users_app
+from kctl_opencloud.core.callbacks import AppContext
+from kctl_lib.self_update import notify_if_outdated
+from kctl_lib.tui import add_tui_command
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"kctl-opencloud {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="kctl-opencloud",
+    help="Kodemeio OpenCloud CLI - manage your OpenCloud file platform.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+    pretty_exceptions_enable=False,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Suppress info messages")] = False,
+    profile: Annotated[str | None, typer.Option("--profile", "-p", help="Config profile name")] = None,
+    url: Annotated[str | None, typer.Option("--url", help="API URL override")] = None,
+    token: Annotated[str | None, typer.Option("--token", help="API token override")] = None,
+    version: Annotated[
+        bool, typer.Option("--version", "-V", callback=version_callback, is_eager=True, help="Show version")
+    ] = False,
+) -> None:
+    """Kodemeio OpenCloud CLI."""
+    ctx.ensure_object(dict)
+    ctx.obj = AppContext(
+        json_mode=json_output,
+        quiet=quiet,
+        profile=profile,
+        url_override=url,
+        token_override=token,
+    )
+    notify_if_outdated(ctx.obj.output, "kctl-opencloud", __version__)
+
+
+# Register command groups
+app.add_typer(health_app, name="health")
+app.add_typer(dashboard_app, name="dashboard")
+app.add_typer(config_app, name="config")
+app.add_typer(users_app, name="users")
+app.add_typer(groups_app, name="groups")
+app.add_typer(spaces_app, name="spaces")
+app.add_typer(shares_app, name="shares")
+app.add_typer(doctor_app, name="doctor")
+app.add_typer(skill_app, name="skill", hidden=True)
+add_tui_command(app, service_key="opencloud", version=__version__)
+
+
+@app.command("self-update")
+def self_update_cmd(ctx: typer.Context) -> None:
+    """Check for updates and upgrade kctl-opencloud."""
+    actx: AppContext = ctx.obj
+    out = actx.output
+
+    from kctl_lib.self_update import check_update
+    from kctl_lib.self_update import update as do_update
+
+    latest = check_update("kctl-opencloud", __version__)
+    if latest:
+        out.info(f"Updating to {latest}...")
+        do_update("kctl-opencloud")
+        out.success(f"Updated to {latest}")
+    else:
+        out.success("Already up to date")
+
+
+@app.command()
+def completions(
+    shell: Annotated[str, typer.Argument(help="Shell type: zsh, bash, fish")] = "zsh",
+    install: Annotated[bool, typer.Option("--install", help="Install completions")] = False,
+) -> None:
+    """Generate or install shell completions."""
+    from kctl_lib.completions import get_completion_script, install_completions
+
+    if install:
+        path = install_completions("kctl-opencloud", shell)
+        if path:
+            typer.echo(f"Completions installed to {path}")
+        else:
+            typer.echo(f"Could not install completions for {shell}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        script = get_completion_script("kctl-opencloud", shell)
+        typer.echo(script)
+
+
+def _run() -> None:
+    """Entry point with error handling."""
+    try:
+        app()
+    except KctlError as e:
+        handle_cli_error(e)
+
+
+if __name__ == "__main__":
+    _run()

kctl_opencloud/commands/config_cmd.py

@@ -0,0 +1,191 @@
+"""Configuration management commands for kctl-opencloud."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from kctl_opencloud.core.callbacks import AppContext
+from kctl_opencloud.core.config import (
+    SERVICE_KEY,
+    ServiceConfig,
+    get_default_profile,
+    get_profile_names,
+    get_service_config,
+    remove_profile,
+    resolve_active_profile_name,
+    set_default_profile,
+    set_service_config,
+)
+
+app = typer.Typer(help="Configuration and profile management.")
+
+
+def _mask_token(token: str) -> str:
+    """Mask a token for display."""
+    if not token or len(token) < 8:
+        return "****" if token else ""
+    return token[:4] + "****" + token[-4:]
+
+
+@app.command()
+def init(
+    ctx: typer.Context,
+    url: Annotated[str, typer.Option("--url", help="OpenCloud API URL")] = "",
+    token: Annotated[str, typer.Option("--token", help="Machine auth API key")] = "",
+    profile_name: Annotated[str, typer.Option("--profile", "-p", help="Profile name")] = "default",
+) -> None:
+    """Initialize configuration with API credentials."""
+    c: AppContext = ctx.obj
+
+    if not url:
+        url = typer.prompt("OpenCloud URL", default="https://cloud.kodeme.io")
+    if not token:
+        token = typer.prompt("Machine Auth API Key", hide_input=True)
+
+    svc = ServiceConfig(url=url, token=token)
+    set_service_config(profile_name, svc)
+    set_default_profile(profile_name)
+
+    # Test connection
+    try:
+        from kctl_opencloud.core.client import OpenCloudClient
+
+        client = OpenCloudClient(base_url=url, credential=token)
+        status = client.check_health()
+        if status == 200:
+            c.output.success(f"Connected to {url}")
+        elif status == 0:
+            c.output.warn(f"Could not reach {url} (connection error)")
+        else:
+            c.output.warn(f"Connection returned HTTP {status}")
+    except Exception as e:
+        c.output.warn(f"Could not verify connection: {e}")
+
+    c.output.success(f"Configuration saved to profile '{profile_name}'")
+
+
+@app.command()
+def show(ctx: typer.Context) -> None:
+    """Show current configuration."""
+    c: AppContext = ctx.obj
+    pname = resolve_active_profile_name(c.profile)
+    svc = get_service_config(pname)
+
+    data = {
+        "profile": pname,
+        "service_key": SERVICE_KEY,
+        "url": svc.url or "(not set)",
+        "token": _mask_token(svc.token),
+        "container_name": svc.container_name or "(default)",
+    }
+
+    sections = [
+        (
+            "Configuration",
+            [
+                ("Profile", data["profile"]),
+                ("Service Key", data["service_key"]),
+                ("URL", data["url"]),
+                ("Token", data["token"]),
+                ("Container", data["container_name"]),
+            ],
+        ),
+    ]
+    c.output.detail("OpenCloud Config", sections, data_for_json=data)
+
+
+@app.command()
+def current(ctx: typer.Context) -> None:
+    """Show the active profile name."""
+    c: AppContext = ctx.obj
+    pname = resolve_active_profile_name(c.profile)
+    c.output.text(pname)
+
+
+@app.command("set")
+def set_(
+    ctx: typer.Context,
+    key: Annotated[str, typer.Argument(help="Config key (url, token, container_name)")],
+    value: Annotated[str, typer.Argument(help="Config value")],
+) -> None:
+    """Set a configuration value."""
+    c: AppContext = ctx.obj
+    valid_fields = set(ServiceConfig.model_fields.keys())
+    if key not in valid_fields:
+        c.output.error(f"Invalid key '{key}'. Valid keys: {', '.join(sorted(valid_fields))}")
+        raise typer.Exit(code=1)
+
+    pname = resolve_active_profile_name(c.profile)
+    svc = get_service_config(pname)
+    setattr(svc, key, value)
+    set_service_config(pname, svc)
+    display_value = _mask_token(value) if "token" in key else value
+    c.output.success(f"Set {key} = {display_value}")
+
+
+@app.command()
+def profiles(ctx: typer.Context) -> None:
+    """List all configuration profiles."""
+    c: AppContext = ctx.obj
+    names = get_profile_names()
+    default = get_default_profile()
+
+    rows = []
+    for name in names:
+        svc = get_service_config(name)
+        marker = "*" if name == default else ""
+        rows.append([marker, name, svc.url or "(not set)"])
+
+    c.output.table(
+        "Profiles",
+        [("", "cyan"), ("Name", "green"), ("URL", "white")],
+        rows,
+        data_for_json=[{"name": n, "default": n == default} for n in names],
+    )
+
+
+@app.command("use")
+def use_(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Profile name to activate")],
+) -> None:
+    """Switch to a different profile."""
+    c: AppContext = ctx.obj
+    names = get_profile_names()
+    if name not in names:
+        c.output.error(f"Profile '{name}' not found. Available: {', '.join(names)}")
+        raise typer.Exit(code=1)
+    set_default_profile(name)
+    c.output.success(f"Switched to profile '{name}'")
+
+
+@app.command()
+def remove(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Profile name to remove")],
+) -> None:
+    """Remove a configuration profile."""
+    c: AppContext = ctx.obj
+    remove_profile(name)
+    c.output.success(f"Removed profile '{name}'")
+
+
+@app.command()
+def test(ctx: typer.Context) -> None:
+    """Test the current connection."""
+    c: AppContext = ctx.obj
+    try:
+        status = c.client.check_health()
+        if status == 200:
+            c.output.success("Connection OK")
+            version = c.client.get_version()
+            if version:
+                c.output.info(f"OpenCloud {version}")
+        else:
+            c.output.error(f"Connection failed (HTTP {status})")
+            raise typer.Exit(code=1)
+    except Exception as e:
+        c.output.error(f"Connection failed: {e}")
+        raise typer.Exit(code=1)

kctl_opencloud/commands/dashboard.py

@@ -0,0 +1,80 @@
+"""Dashboard commands for kctl-opencloud."""
+
+from __future__ import annotations
+
+import time
+from typing import Annotated, Any
+
+import typer
+from kctl_lib.exceptions import AuthenticationError, ConfigError
+
+from kctl_opencloud.core.callbacks import AppContext
+
+app = typer.Typer(help="System overview and statistics.")
+
+
+def _fetch_dashboard(c: AppContext) -> dict[str, Any]:
+    """Fetch dashboard data."""
+    client = c.client
+    data: dict[str, Any] = {}
+
+    # Version
+    data["version"] = client.get_version() or "unknown"
+
+    # Resource counts
+    for resource, endpoint in [("users", "users"), ("groups", "groups"), ("spaces", "drives")]:
+        try:
+            result = client.get(endpoint)
+            data[resource] = len(result.get("value", []))
+        except (AuthenticationError, ConfigError):
+            raise
+        except Exception:
+            data[resource] = 0
+
+    return data
+
+
+def _display_dashboard(c: AppContext, data: dict[str, Any]) -> None:
+    """Display dashboard."""
+    out = c.output
+
+    if c.json_mode:
+        out.raw_json(data)
+        return
+
+    out.header("OpenCloud Dashboard")
+    out.kv("URL", c.client.root_url)
+    out.kv("Version", data["version"])
+    out.text("")
+    out.kv("Users", str(data.get("users", 0)))
+    out.kv("Groups", str(data.get("groups", 0)))
+    out.kv("Spaces", str(data.get("spaces", 0)))
+
+
+@app.callback(invoke_without_command=True)
+def show(
+    ctx: typer.Context,
+    watch: Annotated[bool, typer.Option("--watch", "-w", help="Continuous monitoring")] = False,
+    interval: Annotated[int, typer.Option("--interval", "-i", help="Watch interval")] = 10,
+    compact: Annotated[bool, typer.Option("--compact", "-c", help="Compact output")] = False,
+) -> None:
+    """Show system overview."""
+    c: AppContext = ctx.obj
+
+    if watch:
+        try:
+            while True:
+                data = _fetch_dashboard(c)
+                if compact:
+                    c.output.text(f"Users: {data['users']} | Groups: {data['groups']} | Spaces: {data['spaces']}")
+                else:
+                    _display_dashboard(c, data)
+                time.sleep(interval)
+        except KeyboardInterrupt:
+            pass
+    else:
+        data = _fetch_dashboard(c)
+        if compact:
+            c.output.text(f"Users: {data['users']} | Groups: {data['groups']} | Spaces: {data['spaces']}")
+        else:
+            _display_dashboard(c, data)

kctl_opencloud/commands/doctor_cmd.py

@@ -0,0 +1,110 @@
+"""Diagnostic checks for kctl-opencloud."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import typer
+
+from kctl_opencloud.core.callbacks import AppContext
+
+
+@dataclass
+class CheckResult:
+    name: str
+    status: str  # ok, fail, warn
+    message: str
+    fix_command: str = ""
+
+
+def _check_connectivity(ctx: AppContext) -> CheckResult:
+    """Check API connectivity."""
+    from kctl_opencloud.core.config import get_service_config, resolve_active_profile_name
+
+    try:
+        pname = resolve_active_profile_name(ctx.profile)
+        cfg = get_service_config(pname)
+        if not cfg.url:
+            return CheckResult(
+                "API Connectivity",
+                "fail",
+                "No URL configured",
+                fix_command="kctl-opencloud config init",
+            )
+        # Now try connecting
+        from kctl_opencloud.core.client import OpenCloudClient
+
+        client = OpenCloudClient(base_url=cfg.url, credential=cfg.token)
+        status = client.check_health()
+        if status == 200:
+            return CheckResult("API Connectivity", "ok", f"Connected to {cfg.url}")
+        return CheckResult(
+            "API Connectivity",
+            "warn",
+            f"HTTP {status} from {cfg.url}",
+        )
+    except Exception as e:
+        return CheckResult(
+            "API Connectivity",
+            "fail",
+            str(e),
+            fix_command="kctl-opencloud config init",
+        )
+
+
+def _check_auth(ctx: AppContext) -> CheckResult:
+    """Check authentication."""
+    from kctl_opencloud.core.config import get_service_config, resolve_active_profile_name
+
+    try:
+        pname = resolve_active_profile_name(ctx.profile)
+        cfg = get_service_config(pname)
+        if not cfg.url or not cfg.token:
+            return CheckResult(
+                "Authentication",
+                "fail",
+                "No URL or token configured",
+                fix_command="kctl-opencloud config init",
+            )
+        from kctl_opencloud.core.client import OpenCloudClient
+
+        client = OpenCloudClient(base_url=cfg.url, credential=cfg.token)
+        client.get("me")
+        return CheckResult("Authentication", "ok", "Authenticated")
+    except Exception:
+        return CheckResult(
+            "Authentication",
+            "fail",
+            "Authentication failed",
+            fix_command="kctl-opencloud config set token <your-token>",
+        )
+
+
+app = typer.Typer(help="Diagnostic checks.")
+
+
+@app.callback(invoke_without_command=True)
+def doctor(ctx: typer.Context) -> None:
+    """Run all diagnostic checks."""
+    c: AppContext = ctx.obj
+    out = c.output
+
+    checks = [
+        _check_connectivity(c),
+        _check_auth(c),
+    ]
+
+    all_ok = True
+    for check in checks:
+        if check.status == "ok":
+            out.success(f"{check.name}: {check.message}")
+        elif check.status == "warn":
+            out.warn(f"{check.name}: {check.message}")
+        else:
+            out.error(f"{check.name}: {check.message}")
+            if check.fix_command:
+                out.info(f"  Fix: {check.fix_command}")
+            all_ok = False
+
+    if not all_ok:
+        raise typer.Exit(code=1)

kctl_opencloud/commands/groups.py

@@ -0,0 +1,130 @@
+"""Group 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="Group management.")
+
+
+@app.command("list")
+def list_(
+    ctx: typer.Context,
+    search: Annotated[str | None, typer.Option("--search", "-s", help="Search by name")] = None,
+) -> None:
+    """List all groups."""
+    c: AppContext = ctx.obj
+    params: dict[str, Any] = {}
+    if search:
+        params["$search"] = search
+
+    groups = c.client.get_all("groups", params=params)
+
+    rows = []
+    for g in groups:
+        members = g.get("members", [])
+        rows.append(
+            [
+                g.get("id", ""),
+                g.get("displayName", "-"),
+                str(len(members)) if members else "0",
+            ]
+        )
+
+    c.output.table(
+        "Groups",
+        [("ID", "cyan"), ("Name", "green"), ("Members", "yellow")],
+        rows,
+        data_for_json=groups,
+    )
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    group_id: Annotated[str, typer.Argument(help="Group ID")],
+) -> None:
+    """Get group details."""
+    c: AppContext = ctx.obj
+    group = c.client.get(f"groups/{group_id}")
+
+    members = group.get("members", [])
+    sections = [
+        (
+            "Group",
+            [
+                ("ID", group.get("id", "")),
+                ("Name", group.get("displayName", "-")),
+                ("Members", str(len(members))),
+            ],
+        ),
+    ]
+    c.output.detail("Group Details", sections, data_for_json=group)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Annotated[str, typer.Argument(help="Group display name")],
+) -> None:
+    """Create a new group."""
+    c: AppContext = ctx.obj
+    group = c.client.post("groups", data={"displayName": name})
+    c.output.success(f"Group created: {group.get('displayName', name)}")
+
+
+@app.command()
+def update(
+    ctx: typer.Context,
+    group_id: Annotated[str, typer.Argument(help="Group ID")],
+    name: Annotated[str, typer.Option("--name", "-n", help="New display name")],
+) -> None:
+    """Update a group."""
+    c: AppContext = ctx.obj
+    c.client.patch(f"groups/{group_id}", data={"displayName": name})
+    c.output.success(f"Group {group_id} updated")
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    group_id: Annotated[str, typer.Argument(help="Group ID")],
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation")] = False,
+) -> None:
+    """Delete a group."""
+    c: AppContext = ctx.obj
+    if not force:
+        typer.confirm(f"Delete group {group_id}?", abort=True)
+    c.client.delete(f"groups/{group_id}")
+    c.output.success(f"Group {group_id} deleted")
+
+
+@app.command("add-member")
+def add_member(
+    ctx: typer.Context,
+    group_id: Annotated[str, typer.Argument(help="Group ID")],
+    user_id: Annotated[str, typer.Argument(help="User ID to add")],
+) -> None:
+    """Add a member to a group."""
+    c: AppContext = ctx.obj
+    c.client.post(
+        f"groups/{group_id}/members/$ref",
+        data={"@odata.id": f"{c.client.api_base_url}/users/{user_id}"},
+    )
+    c.output.success(f"User {user_id} added to group {group_id}")
+
+
+@app.command("remove-member")
+def remove_member(
+    ctx: typer.Context,
+    group_id: Annotated[str, typer.Argument(help="Group ID")],
+    user_id: Annotated[str, typer.Argument(help="User ID to remove")],
+) -> None:
+    """Remove a member from a group."""
+    c: AppContext = ctx.obj
+    c.client.delete(f"groups/{group_id}/members/{user_id}/$ref")
+    c.output.success(f"User {user_id} removed from group {group_id}")