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

dwf_cli/cli/schema.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import inspect
+import json as json_mod
+import typing
+from typing import Annotated, Any
+
+import typer
+
+from dwf_cli.cli._common import handle_error
+from dwf_cli.core.errors import DWFError
+from dwf_cli.schemas import lookup
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+app = typer.Typer(
+    help="Show command schemas for agent consumption.",
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+_SCHEMA_VERSION = "1.0"
+
+
+@app.callback(invoke_without_command=True)
+def schema_cmd(
+    ctx: typer.Context,
+    args: Annotated[
+        list[str] | None,
+        typer.Argument(help="Command path, e.g. 'datamodel create'"),
+    ] = None,
+    all_flag: Annotated[
+        bool,
+        typer.Option("--all", help="Show all command schemas"),
+    ] = False,
+) -> None:
+    try:
+        if all_flag or (not args):
+            _output_all()
+            return
+
+        command_path = " ".join(args)
+        _output_single(command_path)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+def _output_all() -> None:
+    root_app = _find_root_app()
+    if root_app is None:
+        typer.echo(json_mod.dumps({"schema_version": _SCHEMA_VERSION, "commands": []}))
+        raise typer.Exit(code=0)
+
+    commands = _flatten_commands(root_app)
+    typer.echo(
+        json_mod.dumps(
+            {"schema_version": _SCHEMA_VERSION, "commands": commands},
+            ensure_ascii=False,
+            indent=2,
+        )
+    )
+    raise typer.Exit(code=0)
+
+
+def _output_single(command_path: str) -> None:
+    root_app = _find_root_app()
+    if root_app is None:
+        raise DWFError(f"Command not found: {command_path}")
+
+    info = _find_command(root_app, command_path)
+    if info is None:
+        raise DWFError(
+            f"Command not found: {command_path}. "
+            "Run 'dwf-cli schema --all' to see all available commands",
+        )
+
+    typer.echo(json_mod.dumps(info, ensure_ascii=False, indent=2))
+    raise typer.Exit(code=0)
+
+
+def _find_root_app() -> typer.Typer | None:
+    import dwf_cli.cli as cli_mod
+
+    return getattr(cli_mod, "app", None)
+
+
+def _flatten_commands(typer_app: typer.Typer, prefix: str = "") -> list[dict[str, Any]]:
+    results: list[dict[str, Any]] = []
+
+    for cmd in typer_app.registered_commands:
+        cmd_name = cmd.name or cmd.callback.__name__ if cmd.callback else None
+        if cmd_name is None:
+            continue
+        full_path = f"{prefix} {cmd_name}".strip() if prefix else cmd_name
+        info = _build_command_info(cmd, full_path)
+        results.append(info)
+
+    for group in typer_app.registered_groups:
+        group_name = group.name
+        if group_name is None:
+            continue
+        sub_app = group.typer_instance
+        if sub_app is not None:
+            group_prefix = f"{prefix} {group_name}".strip() if prefix else group_name
+            results.extend(_flatten_commands(sub_app, prefix=group_prefix))
+
+    return results
+
+
+def _find_command(
+    typer_app: typer.Typer,
+    command_path: str,
+    full_path: str = "",
+) -> dict[str, Any] | None:
+    parts = command_path.split()
+    resolved = full_path or command_path
+
+    if len(parts) == 1:
+        for cmd in typer_app.registered_commands:
+            cmd_name = cmd.name or cmd.callback.__name__ if cmd.callback else None
+            if cmd_name == parts[0]:
+                return _build_command_info(cmd, resolved)
+
+    for group in typer_app.registered_groups:
+        group_name = group.name
+        if group_name is None or group_name == "schema":
+            continue
+        if parts[0] == group_name:
+            sub_app = group.typer_instance
+            if sub_app is not None:
+                remaining = " ".join(parts[1:])
+                return _find_command(sub_app, remaining, full_path=resolved)
+
+    return None
+
+
+def _build_command_info(
+    cmd: typer.models.CommandInfo,
+    full_path: str,
+) -> dict[str, Any]:
+    info: dict[str, Any] = {"command": full_path}
+
+    if cmd.help:
+        info["help"] = cmd.help
+
+    params = _extract_params(cmd)
+    if params:
+        info["params"] = params
+
+    body = lookup(full_path)
+    if body:
+        info["body"] = body
+
+    return info
+
+
+def _extract_params(cmd: typer.models.CommandInfo) -> list[dict[str, Any]]:
+    params: list[dict[str, Any]] = []
+    if cmd.callback is None:
+        return params
+
+    try:
+        hints = typing.get_type_hints(cmd.callback, include_extras=True)
+    except Exception:
+        hints = {}
+    sig = inspect.signature(cmd.callback)
+
+    for pname, p in sig.parameters.items():
+        hint = hints.get(pname)
+        if hint is None or not hasattr(hint, "__metadata__"):
+            continue
+
+        for meta in hint.__metadata__:
+            if isinstance(meta, typer.models.OptionInfo):
+                pi: dict[str, Any] = {"name": pname, "kind": "option"}
+                if meta.param_decls:
+                    long_names = [d for d in meta.param_decls if d.startswith("--")]
+                    short_names = [
+                        d
+                        for d in meta.param_decls
+                        if d.startswith("-") and not d.startswith("--")
+                    ]
+                    if long_names:
+                        pi["option"] = long_names[0]
+                    elif meta.param_decls:
+                        pi["option"] = meta.param_decls[0]
+                    if short_names:
+                        pi["short"] = short_names[0]
+                pi["help"] = meta.help or ""
+                has_default = p.default is not inspect.Parameter.empty
+                pi["required"] = not has_default
+                if has_default:
+                    pi["default"] = p.default
+                args = getattr(hint, "__args__", None)
+                if args:
+                    base = args[0]
+                    if hasattr(base, "__members__"):
+                        pi["enum"] = list(base.__members__.keys())
+                params.append(pi)
+                break
+            if isinstance(meta, typer.models.ArgumentInfo):
+                pi = {
+                    "name": pname,
+                    "kind": "argument",
+                    "required": True,
+                    "help": meta.help or "",
+                }
+                params.append(pi)
+                break
+
+    return params

dwf_cli/core/config.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+import typer
+
+from dwf_cli.core.crypto import DEFAULT_AES_KEY, DEFAULT_AES_IV
+from dwf_cli.core.errors import ConfigError
+
+
+def parse_config_js(content: str, source_url: str | None = None) -> dict[str, str]:
+    result: dict[str, str] = {}
+
+    _FIELD_MAP: dict[str, str] = {
+        "modelerApiBase": "server",
+        "appApiBase": "app_server",
+        "aesKeyB": "aes_key",
+        "aesIv": "aes_iv",
+    }
+
+    source_parts = None
+    if source_url:
+        parsed = urlparse(source_url)
+        source_parts = {
+            "protocol": parsed.scheme,
+            "ip": parsed.hostname or "",
+            "port": str(parsed.port or ""),
+        }
+
+    for js_key, config_key in _FIELD_MAP.items():
+        pattern = rf"{js_key}\s*:\s*`([^`]*)`"
+        m = re.search(pattern, content)
+        if not m:
+            pattern2 = rf"{js_key}\s*:\s*'([^']*)'"
+            m = re.search(pattern2, content)
+        if not m:
+            continue
+        raw = m.group(1)
+        if source_parts:
+            proto = source_parts["protocol"]
+            raw = raw.replace("${protocol}", f"{proto}:")
+            raw = raw.replace("${ip}", source_parts["ip"])
+            raw = raw.replace("${port}", source_parts["port"])
+        if raw:
+            result[config_key] = raw
+
+    return result
+
+
+def resolve_config_js_url(raw_input: str) -> str:
+    raw = raw_input.strip()
+    if (
+        re.match(r"^[A-Za-z]:\\", raw)
+        or raw.startswith("/")
+        or raw.startswith("./")
+        or raw.startswith("..\\")
+        or (not raw.startswith(("http://", "https://")) and Path(raw).exists())
+    ):
+        return raw
+    if not raw.startswith(("http://", "https://")):
+        raw = "http://" + raw
+    if raw.endswith("/config.js"):
+        return raw
+    for suffix in ("/modeler-api", "/app-api", "/monitor-api"):
+        if raw.endswith(suffix):
+            return raw[: -len(suffix)] + "/config.js"
+    if re.search(r"/modeler-web/?$", raw):
+        return raw.rstrip("/") + "/config.js"
+    return raw.rstrip("/") + "/modeler-web/config.js"
+
+
+class Config:
+    _DIR: Path = Path(typer.get_app_dir("dwf-cli"))
+    _FILE: Path = _DIR / "config.json"
+
+    _URL_KEYS = {"server", "app_server"}
+
+    def __init__(self) -> None:
+        self._data: dict[str, object] = {}
+        self._DIR.mkdir(parents=True, exist_ok=True)
+        if self._FILE.exists():
+            try:
+                self._data = json.loads(self._FILE.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError) as exc:
+                raise ConfigError(f"Failed to read config: {exc}") from exc
+
+    @property
+    def server(self) -> str | None:
+        value = self._data.get("server")
+        return str(value) if value is not None else None
+
+    @property
+    def app_server(self) -> str | None:
+        if "app_server" in self._data:
+            return str(self._data["app_server"])
+        return self.server
+
+    @property
+    def token(self) -> str | None:
+        value = self._data.get("token")
+        return str(value) if value is not None else None
+
+    @property
+    def aes_key(self) -> str:
+        return str(self._data.get("aes_key", DEFAULT_AES_KEY))
+
+    @property
+    def aes_iv(self) -> str:
+        return str(self._data.get("aes_iv", DEFAULT_AES_IV))
+
+    def save_token(self, token: str) -> None:
+        self._data["token"] = token
+        self._save()
+
+    def clear_token(self) -> None:
+        self._data.pop("token", None)
+        self._save()
+
+    _BLOCKED_PROTOCOLS = ("javascript:", "file:", "data:", "vbscript:")
+
+    def set(self, key: str, value: str) -> None:
+        if key in self._URL_KEYS:
+            self._validate_server_url(value)
+        self._data[key] = value
+        self._save()
+
+    @classmethod
+    def _validate_server_url(cls, url: str) -> None:
+        lower = url.strip().lower()
+        for proto in cls._BLOCKED_PROTOCOLS:
+            if lower.startswith(proto):
+                raise ConfigError(
+                    f"Blocked protocol '{proto.rstrip(':')}' in server URL",
+                    detail=f"server={url}",
+                )
+        if "://" in lower and not lower.startswith(("http://", "https://")):
+            raise ConfigError(
+                "Only http/https protocols allowed for server URL",
+                detail=f"server={url}",
+            )
+
+    def get(self, key: str) -> str | None:
+        value = self._data.get(key)
+        return str(value) if value is not None else None
+
+    def bulk_set(self, items: dict[str, str]) -> list[str]:
+        updated: list[str] = []
+        for key, value in items.items():
+            if key in self._URL_KEYS:
+                self._validate_server_url(value)
+            self._data[key] = value
+            updated.append(key)
+        if updated:
+            self._save()
+        return updated
+
+    def list_all(self) -> dict[str, Any]:
+        safe: dict[str, Any] = {}
+        for k, v in self._data.items():
+            if k == "token":
+                safe[k] = "***"
+            else:
+                safe[k] = v
+        return safe
+
+    def _save(self) -> None:
+        try:
+            self._FILE.write_text(
+                json.dumps(self._data, indent=2, ensure_ascii=False),
+                encoding="utf-8",
+            )
+        except OSError as exc:
+            raise ConfigError(f"Failed to write config: {exc}") from exc

dwf_cli/core/crypto.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import base64
+import random
+import string
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad
+
+DEFAULT_AES_KEY = "vndKmU#KbOxpifI0"
+DEFAULT_AES_IV = "KPXUGHNBRWLYKRTE"
+
+
+def encrypt_password(raw_password: str, key: str, iv: str) -> str:
+    cipher = AES.new(key.encode("utf-8"), AES.MODE_CBC, iv.encode("utf-8"))
+    padded = pad(raw_password.encode("utf-8"), AES.block_size)
+    ciphertext = cipher.encrypt(padded)
+    b64_once = base64.b64encode(ciphertext).decode("utf-8")
+    b64_twice = base64.b64encode(b64_once.encode("utf-8")).decode("utf-8")
+    prefix = "".join(random.choices(string.ascii_letters + string.digits, k=3))
+    suffix = "".join(random.choices(string.ascii_letters + string.digits, k=5))
+    return f"{prefix}{b64_twice}{suffix}"

dwf_cli/core/errors.py

@@ -0,0 +1,63 @@
+_RETRYABLE_STATUS = {408, 429, 502, 503, 504}
+
+
+class ExitCode:
+    SUCCESS = 0
+    GENERAL = 1
+    AUTH = 2
+    NOT_FOUND = 3
+    API = 4
+    CONFLICT = 5
+    CONFIG = 6
+
+
+class DWFError(Exception):
+    exit_code: int = ExitCode.GENERAL
+    retryable: bool = False
+    suggestion: str | None = None
+
+    def __init__(self, message: str, *, detail: str | None = None) -> None:
+        self.detail = detail
+        super().__init__(message)
+
+
+class AuthError(DWFError):
+    exit_code = ExitCode.AUTH
+    retryable = False
+    suggestion = "检查登录状态，运行 dwf-cli auth login"
+
+
+class NotFoundError(DWFError):
+    exit_code = ExitCode.NOT_FOUND
+    retryable = False
+    suggestion = "确认资源名称或 OID 是否正确"
+
+
+class ConflictError(DWFError):
+    exit_code = ExitCode.CONFLICT
+    retryable = False
+    suggestion = "资源已存在，使用 --if-not-exists 跳过"
+
+    def __init__(self, message: str, *, detail: str | None = None) -> None:
+        self.detail = detail
+        super().__init__(message)
+
+
+class APIError(DWFError):
+    exit_code = ExitCode.API
+    retryable = False
+    suggestion = "检查网络连接和服务器状态"
+
+    def __init__(self, status: int, message: str) -> None:
+        self.status = status
+        self.message = message
+        if status in _RETRYABLE_STATUS:
+            self.retryable = True
+            self.suggestion = "服务器暂时不可用，建议稍后重试"
+        super().__init__(f"API error {status}: {message}")
+
+
+class ConfigError(DWFError):
+    exit_code = ExitCode.CONFIG
+    retryable = False
+    suggestion = "运行 dwf-cli config set 检查配置项"

dwf_cli/core/output.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class OutputFormat(str, Enum):
+    table = "table"
+    json = "json"

dwf_cli/core/validator.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+_TYPE_MAP: dict[str, type | tuple[type, ...]] = {
+    "string": str,
+    "integer": (int,),
+    "boolean": (bool,),
+    "number": (int, float),
+    "array": (list,),
+    "object": (dict,),
+}
+
+
+def validate_body(schema: dict[str, Any], data: Any) -> list[str]:
+    errors: list[str] = []
+
+    body_type = schema.get("type", "object")
+    if body_type == "array" and not isinstance(data, list):
+        errors.append(f"Expected array, got {type(data).__name__}")
+        return errors
+    if body_type == "object" and not isinstance(data, dict):
+        errors.append(f"Expected object, got {type(data).__name__}")
+        return errors
+
+    if schema.get("dynamic"):
+        return _validate_dynamic(schema, data, errors)
+
+    fields = schema.get("fields", [])
+    if not fields:
+        return errors
+
+    if body_type == "array":
+        if not data:
+            errors.append("Array must not be empty")
+            return errors
+        for i, item in enumerate(data):
+            item_errors = _validate_fields(fields, item, prefix=f"[{i}]")
+            errors.extend(item_errors)
+    else:
+        errors.extend(_validate_fields(fields, data))
+
+    return errors
+
+
+def _validate_fields(
+    fields: list[dict[str, Any]],
+    data: dict[str, Any],
+    prefix: str = "",
+) -> list[str]:
+    errors: list[str] = []
+
+    for field in fields:
+        name = field["name"]
+        required = field.get("required", False)
+        path = f"{prefix}.{name}" if prefix else name
+
+        if required and name not in data:
+            errors.append(f"Missing required field: {path}")
+            continue
+
+        if name not in data:
+            continue
+
+        value = data[name]
+        value_errors = _validate_field_value(field, value, path)
+        errors.extend(value_errors)
+
+    return errors
+
+
+def _validate_field_value(
+    field: dict[str, Any],
+    value: Any,
+    path: str,
+) -> list[str]:
+    errors: list[str] = []
+
+    expected_type = field.get("type")
+    if expected_type and expected_type in _TYPE_MAP:
+        py_type = _TYPE_MAP[expected_type]
+        if expected_type == "boolean" and isinstance(value, int):
+            errors.append(f"Field {path}: expected boolean, got int")
+        elif not isinstance(value, py_type):
+            errors.append(
+                f"Field {path}: expected {expected_type}, got {type(value).__name__}"
+            )
+            return errors
+
+    enum_values = field.get("enum")
+    if enum_values and value not in enum_values:
+        errors.append(f"Field {path}: value '{value}' not in enum {enum_values}")
+
+    if "item_schema" in field and isinstance(value, list):
+        item_fields = field["item_schema"].get("fields", [])
+        for i, item in enumerate(value):
+            if isinstance(item, dict):
+                item_errors = _validate_fields(item_fields, item, prefix=f"{path}[{i}]")
+                errors.extend(item_errors)
+
+    return errors
+
+
+def _validate_dynamic(
+    schema: dict[str, Any],
+    data: Any,
+    errors: list[str],
+) -> list[str]:
+    fields = schema.get("fields", [])
+    if not fields:
+        return errors
+
+    if isinstance(data, list):
+        for i, item in enumerate(data):
+            if isinstance(item, dict):
+                for field in fields:
+                    name = field["name"]
+                    required = field.get("required", False)
+                    if required and name not in item:
+                        errors.append(f"Missing required field: [{i}].{name}")
+    elif isinstance(data, dict):
+        for field in fields:
+            name = field["name"]
+            required = field.get("required", False)
+            if required and name not in data:
+                errors.append(f"Missing required field: {name}")
+
+    return errors

dwf_cli/mcp/__init__.py

@@ -0,0 +1,3 @@
+from dwf_cli.mcp.server import mcp
+
+__all__ = ["mcp"]