dwf-platform-cli 0.2.0__py3-none-any.whl

dwf_cli/cli/_common.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json as json_mod
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich.console import Console
+
+from dwf_cli.api.client import APIClient
+from dwf_cli.core.config import Config
+from dwf_cli.core.errors import AuthError, DWFError
+from dwf_cli.core.output import OutputFormat
+
+_SENSITIVE_DIRS = {".ssh", ".gnupg", ".aws", ".kube"}
+
+
+@dataclass
+class ContextObj:
+    config: Config
+    client: APIClient | None
+    app_client: APIClient | None = None
+
+
+@dataclass
+class SuccessResult:
+    action: str
+    resource: str
+    detail: str | None = None
+    data: Any = None
+
+
+def report_success(
+    result: SuccessResult, fmt: OutputFormat = OutputFormat.table
+) -> None:
+    fmt = resolve_format(fmt)
+    if fmt == OutputFormat.json:
+        obj: dict[str, Any] = {
+            "success": True,
+            "action": result.action,
+            "resource": result.resource,
+        }
+        if result.detail:
+            obj["detail"] = result.detail
+        if result.data is not None:
+            obj["data"] = result.data
+        typer.echo(json_mod.dumps(obj, ensure_ascii=False, indent=2))
+    else:
+        msg = f"{result.action} {result.resource}"
+        if result.detail:
+            msg += f": {result.detail}"
+        Console().print(f"[green]{msg}[/green]")
+
+
+def is_tty() -> bool:
+    return sys.stdout.isatty()
+
+
+def _should_disable_color() -> bool:
+    if os.environ.get("NO_COLOR") is not None:
+        return True
+    if os.environ.get("TERM") == "dumb":
+        return True
+    if not is_tty():
+        return True
+    return False
+
+
+_console: Console | None = None
+
+
+def get_console() -> Console:
+    global _console
+    if _console is None:
+        _console = Console(no_color=_should_disable_color())
+    return _console
+
+
+def resolve_format(fmt: OutputFormat) -> OutputFormat:
+    if fmt == OutputFormat.table and not is_tty():
+        return OutputFormat.json
+    return fmt
+
+
+def validate_path(path: Path) -> Path:
+    resolved = path.resolve()
+    for part in resolved.parts:
+        if part in _SENSITIVE_DIRS:
+            raise DWFError(f"Path contains sensitive directory: {part}")
+    if ".." in str(path):
+        raise DWFError("Path traversal not allowed")
+    return resolved
+
+
+def get_client(ctx: typer.Context) -> APIClient:
+    obj: ContextObj = ctx.obj
+    if obj.client is None:
+        raise AuthError("Not logged in")
+    return obj.client
+
+
+def get_app_client(ctx: typer.Context) -> APIClient:
+    obj: ContextObj = ctx.obj
+    if obj.app_client is not None:
+        return obj.app_client
+    if obj.client is not None:
+        return obj.client
+    raise AuthError("Not logged in")
+
+
+def handle_error(exc: DWFError) -> None:
+    if is_tty():
+        parts = [f"Error: {exc}"]
+        if exc.suggestion:
+            parts.append(f"  建议: {exc.suggestion}")
+        if exc.detail:
+            parts.append(f"  详情: {exc.detail}")
+        typer.echo("\n".join(parts), err=True)
+    else:
+        _print_error_json(
+            type(exc).__name__,
+            str(exc),
+            exc.suggestion,
+            retryable=exc.retryable,
+            detail=exc.detail,
+        )
+    raise typer.Exit(code=exc.exit_code)
+
+
+def _print_error_json(
+    error_type: str,
+    message: str,
+    suggestion: str | None,
+    retryable: bool = False,
+    *,
+    detail: str | None = None,
+) -> None:
+    import json as json_mod
+
+    error_obj: dict[str, Any] = {
+        "error": error_type,
+        "message": message,
+        "retryable": retryable,
+    }
+    if suggestion:
+        error_obj["suggestion"] = suggestion
+    if detail:
+        error_obj["detail"] = detail
+    typer.echo(json_mod.dumps(error_obj, ensure_ascii=False), err=True)

dwf_cli/cli/auth.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from dwf_cli.api import auth as auth_api
+from dwf_cli.api.client import APIClient
+from dwf_cli.cli._common import (
+    ContextObj,
+    handle_error,
+    is_tty,
+    resolve_format,
+    validate_path,
+)
+from dwf_cli.core.errors import AuthError, ConfigError, DWFError
+from dwf_cli.core.output import OutputFormat
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+DRY_RUN_EXIT_CODE = 10
+
+app = typer.Typer(
+    help="User authentication.\n\n"
+    "Examples:\n"
+    "  dwf-cli auth login --username admin --password-file /path/to/password\n"
+    "  dwf-cli auth login --username admin  (prompts for password in TTY)\n"
+    "  dwf-cli auth status\n"
+    "  dwf-cli auth logout",
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+
+@app.command()
+def login(
+    ctx: typer.Context,
+    username: Annotated[
+        str,
+        typer.Option(
+            prompt=is_tty(),
+            help="Username (required; will prompt in TTY mode)",
+        ),
+    ],
+    password_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--password-file",
+            help="Read password from file (first line, trailing newline stripped)",
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        password = ""
+        if password_file:
+            password_file = validate_path(password_file)
+            password = password_file.read_text(encoding="utf-8").splitlines()[0]
+        elif is_tty():
+            password = typer.prompt("Password", hide_input=True)
+        else:
+            raise AuthError(
+                "Password required in non-TTY mode",
+                detail="Use --password-file or run in TTY mode",
+            )
+
+        obj: ContextObj = ctx.obj
+        server = obj.config.server
+        if not server:
+            raise ConfigError(
+                "Server not configured",
+                detail="Run 'dwf-cli config set server <url>' first",
+            )
+
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "login",
+                        "resource": "auth",
+                        "server": server,
+                        "username": username,
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        temp_client = APIClient(server)
+        token = auth_api.login(
+            temp_client,
+            username,
+            password,
+            aes_key=obj.config.aes_key,
+            aes_iv=obj.config.aes_iv,
+        )
+        obj.config.save_token(token)
+        typer.echo(f"Logged in to {server}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def logout(
+    ctx: typer.Context,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        obj: ContextObj = ctx.obj
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "logout",
+                        "resource": "auth",
+                        "has_token": bool(obj.config.token),
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        obj.config.clear_token()
+        typer.echo("Logged out.", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def status(
+    ctx: typer.Context,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    obj: ContextObj = ctx.obj
+    fmt = resolve_format(fmt)
+
+    if not obj.config.token:
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps({"logged_in": False}))
+        else:
+            typer.echo("Not logged in.")
+        return
+
+    if obj.client is None:
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps({"logged_in": False, "reason": "no_server"}))
+        else:
+            typer.echo("Not logged in (no server configured).")
+        return
+
+    try:
+        valid = auth_api.validate_token(obj.client)
+        if valid:
+            if fmt == OutputFormat.json:
+                typer.echo(
+                    json_mod.dumps(
+                        {"logged_in": True, "server": obj.config.server},
+                        ensure_ascii=False,
+                    )
+                )
+            else:
+                typer.echo(f"Logged in ({obj.config.server})")
+        else:
+            if fmt == OutputFormat.json:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "logged_in": False,
+                            "server": obj.config.server,
+                            "reason": "token_expired",
+                        },
+                        ensure_ascii=False,
+                    )
+                )
+            else:
+                typer.echo("Token expired. Run 'dwf-cli auth login' again.")
+    except DWFError:
+        if fmt == OutputFormat.json:
+            typer.echo(
+                json_mod.dumps({"logged_in": False, "reason": "server_unreachable"})
+            )
+        else:
+            typer.echo("Token expired or server unreachable.")

dwf_cli/cli/config.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json as json_mod
+from pathlib import Path
+from typing import Annotated, Any
+
+import httpx
+import typer
+
+from dwf_cli.cli._common import ContextObj, handle_error, resolve_format
+from dwf_cli.core.config import parse_config_js, resolve_config_js_url
+from dwf_cli.core.errors import ConfigError, DWFError
+from dwf_cli.core.output import OutputFormat
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+DRY_RUN_EXIT_CODE = 10
+
+app = typer.Typer(
+    help="CLI configuration.\n\n"
+    "Examples:\n"
+    "  dwf-cli config set server https://your-dwf-server.com\n"
+    "  dwf-cli config get server\n"
+    "  dwf-cli config list\n"
+    "  dwf-cli config detect http://host:6060 --save",
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+
+@app.command(name="list")
+def list_config(
+    ctx: typer.Context,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        obj: ContextObj = ctx.obj
+        data = obj.config.list_all()
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(data, ensure_ascii=False, indent=2))
+        else:
+            for key, value in data.items():
+                typer.echo(f"  {key} = {value}")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def get(
+    ctx: typer.Context,
+    key: Annotated[str, typer.Argument(help="Config key")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        obj: ContextObj = ctx.obj
+        value = obj.config.get(key)
+        if value is None:
+            raise ConfigError(f"Key not found: {key}")
+
+        fmt = resolve_format(fmt)
+
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps({key: value}, ensure_ascii=False, indent=2))
+        else:
+            typer.echo(f"{key} = {value}")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def set(
+    ctx: typer.Context,
+    key: Annotated[str, typer.Argument(help="Config key")],
+    value: Annotated[str, typer.Argument(help="Config value")],
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without executing"),
+    ] = False,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "set",
+                        "resource": "config",
+                        "key": key,
+                        "value": value,
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+
+        obj: ContextObj = ctx.obj
+        obj.config.set(key, value)
+        typer.echo(f"Set {key} = {value}", err=True)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@app.command()
+def detect(
+    ctx: typer.Context,
+    source: Annotated[
+        str,
+        typer.Argument(
+            help="DWF server URL or local config.js path. "
+            "Examples: http://host:6060, http://host/modeler-web, ./config.js"
+        ),
+    ],
+    save: Annotated[
+        bool,
+        typer.Option("--save", help="Save detected config to config file"),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Preview without saving"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        resolved = resolve_config_js_url(source)
+        content: str | None = None
+        actual_url: str | None = None
+
+        p = Path(resolved)
+        if p.exists() and p.is_file():
+            content = p.read_text(encoding="utf-8")
+        else:
+            actual_url = resolved
+            try:
+                resp = httpx.get(resolved, timeout=15.0, follow_redirects=True)
+                resp.raise_for_status()
+                content = resp.text
+            except httpx.HTTPError as exc:
+                err = ConfigError(f"Failed to fetch config.js from {resolved}: {exc}")
+                err.suggestion = "Check the URL or provide a local config.js file path"
+                raise err
+
+        detected = parse_config_js(content, source_url=actual_url)
+        if not detected:
+            err = ConfigError(f"No DWF config fields found in {resolved}")
+            err.suggestion = (
+                "Ensure the file contains modelerApiBase or appApiBase fields"
+            )
+            raise err
+
+        if dry_run or not save:
+            fmt = resolve_format(fmt)
+            if fmt == OutputFormat.json:
+                output: dict[str, Any] = {
+                    "source": resolved,
+                    "detected": detected,
+                    "saved": False,
+                }
+                typer.echo(json_mod.dumps(output, ensure_ascii=False, indent=2))
+            else:
+                typer.echo(f"Detected from {resolved}:", err=True)
+                for key, value in detected.items():
+                    typer.echo(f"  {key} = {value}", err=True)
+                if not save and not dry_run:
+                    typer.echo("  (use --save to write to config)", err=True)
+            if dry_run:
+                raise typer.Exit(code=DRY_RUN_EXIT_CODE)
+        else:
+            obj: ContextObj = ctx.obj
+            updated = obj.config.bulk_set(detected)
+            fmt = resolve_format(fmt)
+            if fmt == OutputFormat.json:
+                typer.echo(
+                    json_mod.dumps(
+                        {
+                            "source": resolved,
+                            "detected": detected,
+                            "saved": True,
+                            "updated_keys": updated,
+                        },
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+            else:
+                typer.echo(f"Detected and saved from {resolved}:", err=True)
+                for key in updated:
+                    typer.echo(f"  {key} = {detected[key]}", err=True)
+    except DWFError as exc:
+        handle_error(exc)