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

dwf_cli/cli/funcmodel.py

@@ -0,0 +1,2055 @@
+from __future__ import annotations
+
+import base64
+import json as json_mod
+import re
+import secrets
+import string as string_mod
+from enum import Enum
+from pathlib import Path
+from typing import Annotated, Any
+
+import pypinyin
+import typer
+from rich.table import Table
+
+from dwf_cli.api import funcmodel as funcmodel_api
+from dwf_cli.api.client import raise_if_not_success
+from dwf_cli.cli._common import (
+    SuccessResult,
+    get_client,
+    get_console,
+    handle_error,
+    is_tty,
+    report_success,
+    resolve_format,
+)
+from dwf_cli.core.errors import DWFError
+from dwf_cli.core.output import OutputFormat
+
+_HELP_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+app = typer.Typer(
+    help="Function model management.\n\n"
+    "Examples:\n"
+    "  # App commands\n"
+    "  dwf-cli funcmodel app list\n"
+    "  dwf-cli funcmodel app get --name MyApp\n"
+    "  dwf-cli funcmodel app create --title '我的应用'\n"
+    "  dwf-cli funcmodel app create --title '设备管理' --type Mobile --app-name DeviceApp\n"
+    "  dwf-cli funcmodel app create --data-file ./app.json\n"
+    "  dwf-cli funcmodel app update --title '新名称' --data-file ./patch.json\n"
+    "  dwf-cli funcmodel app delete --id app_abc123\n"
+    "  dwf-cli funcmodel app upload-logo --id app_abc123 --file ./logo.png\n\n"
+    "  # Theme commands\n"
+    "  dwf-cli funcmodel theme list\n"
+    "  dwf-cli funcmodel theme create --name my-theme --file ./style.css --note '注释'\n"
+    "  dwf-cli funcmodel theme update THEME_OID --file ./new.css --name updated-theme\n\n"
+    "  # Language package commands\n"
+    "  dwf-cli funcmodel language-package list --app-id MyApp\n"
+    '  dwf-cli funcmodel language-package create --data \'"{\\"appId\\":\\"MyApp\\",\\"language\\":\\"zh_CN\\"}"\' --file ./zh_CN.json\n'
+    "  dwf-cli funcmodel language-package update PKG_ID --file ./zh_CN_updated.json\n\n"
+    "  # Operations commands\n"
+    "  dwf-cli funcmodel operations list -t entity --search Animate\n"
+    "  dwf-cli funcmodel operations list -t global -p 0 -s 10\n"
+    "  dwf-cli funcmodel operations all\n"
+    "  dwf-cli funcmodel operations keywords\n"
+    "  dwf-cli funcmodel operations get OPR_OID\n"
+    "  dwf-cli funcmodel operations get-by-ids --id OID1 --id OID2\n"
+    "  dwf-cli funcmodel operations create --data-file ./operation.json\n"
+    "  dwf-cli funcmodel operations update --data-file ./operation_update.json\n"
+    "  dwf-cli funcmodel operations delete OPR_OID\n"
+    "  dwf-cli funcmodel operations move OPR_OID --parent-id PARENT_OID\n"
+    "  dwf-cli funcmodel operations hide OPR_OID --hide\n"
+    "  dwf-cli funcmodel operations hide OPR_OID --show\n"
+    '  dwf-cli funcmodel operations check-name --data \'{"displayName":"测试"}\'\n'
+    "  dwf-cli funcmodel operations global-scripts\n\n"
+    "  # Module commands\n"
+    "  dwf-cli funcmodel modules list --app-id MyApp\n"
+    "  dwf-cli funcmodel modules list --with-default\n"
+    "  dwf-cli funcmodel modules tree\n"
+    "  dwf-cli funcmodel modules tree --app-id MyApp --with-hidden\n"
+    "  dwf-cli funcmodel modules operations MyModule\n"
+    '  dwf-cli funcmodel modules update-order MyApp --data \'[{"id":"module1","className":"Module1","children":[]}]\'',
+    context_settings=_HELP_CONTEXT_SETTINGS,
+)
+
+_app_sub = typer.Typer(
+    help="Application management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+_theme_sub = typer.Typer(
+    help="Theme management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+_lang_pkg_sub = typer.Typer(
+    help="Language package management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+_operations_sub = typer.Typer(
+    help="Operations management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+_modules_sub = typer.Typer(
+    help="Module management.", context_settings=_HELP_CONTEXT_SETTINGS
+)
+
+app.add_typer(_app_sub, name="app")
+app.add_typer(_theme_sub, name="theme")
+app.add_typer(_lang_pkg_sub, name="language-package")
+app.add_typer(_operations_sub, name="operations")
+app.add_typer(_modules_sub, name="modules")
+
+
+class OperationType(str, Enum):
+    global_ = "global"
+    entity = "entity"
+    relation = "relation"
+
+
+# ── Shared helpers ────────────────────────────────────────────────────
+
+
+def _resolve_data(data: str | None, data_file: Path | None) -> str:
+    if data_file:
+        return data_file.read_text(encoding="utf-8")
+    if data is not None:
+        return data
+    raise typer.BadParameter("Provide --data <json> or --data-file <path>")
+
+
+def _extract_items(result: Any) -> list[dict[str, Any]]:
+    if isinstance(result, list):
+        return result
+    if isinstance(result, dict):
+        payload = result.get("data", result)
+        if isinstance(payload, dict):
+            items = payload.get("data", payload.get("items", []))
+            return items if isinstance(items, list) else []
+        if isinstance(payload, list):
+            return payload
+    return []
+
+
+def _flatten_operations(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    flat: list[dict[str, Any]] = []
+    for item in items:
+        if not isinstance(item, dict):
+            flat.append(item)
+            continue
+        is_grouped = True
+        for v in item.values():
+            if not isinstance(v, list):
+                is_grouped = False
+                break
+        if is_grouped and item:
+            for class_name, ops in item.items():
+                if isinstance(ops, list):
+                    for op in ops:
+                        if isinstance(op, dict):
+                            row = {"className": class_name}
+                            row.update(op)
+                            flat.append(row)
+                        else:
+                            flat.append({"className": class_name, "value": op})
+        else:
+            flat.append(item)
+    return flat
+
+
+def _extract_page_info(result: Any) -> dict[str, Any] | None:
+    if isinstance(result, dict):
+        pi = result.get("pageInfo")
+        if isinstance(pi, dict):
+            return pi
+        payload = result.get("data")
+        if isinstance(payload, dict):
+            return payload.get("pageInfo")
+    return None
+
+
+def _print_table(
+    items: list[dict[str, Any]],
+    title: str,
+    columns: list[str] | None = None,
+    page_info: dict[str, Any] | None = None,
+) -> None:
+    console = get_console()
+    cols = columns or list(items[0].keys()) if items else []
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+    table.add_column("#", style="dim", width=4)
+    for col in cols:
+        table.add_column(col)
+    for idx, item in enumerate(items, 1):
+        row = [str(idx)] + [str(item.get(col, "")) for col in cols]
+        table.add_row(*row)
+    console.print(table)
+    if page_info:
+        total = page_info.get("totalCount", "?")
+        console.print(
+            f"[dim]Page {page_info.get('pageIndex', '?')}, "
+            f"Size {page_info.get('pageSize', '?')}, "
+            f"Total {total}[/dim]"
+        )
+    else:
+        console.print(f"[dim]Total {len(items)} items[/dim]")
+
+
+# ── App helpers ────────────────────────────────────────────────────────
+
+
+def _validate_create_params(parsed: dict[str, Any]) -> None:
+    title_val = parsed.get("title", "")
+    if isinstance(title_val, str) and len(title_val) > 32:
+        raise typer.BadParameter(
+            f"--title must not exceed 32 characters (got {len(title_val)})"
+        )
+    app_name_val = parsed.get("appName", "")
+    if isinstance(app_name_val, str):
+        if len(app_name_val) > 32:
+            raise typer.BadParameter(
+                f"--app-name must not exceed 32 characters (got {len(app_name_val)})"
+            )
+        if app_name_val and not app_name_val[0].isalpha():
+            raise typer.BadParameter("--app-name must start with a letter")
+        if app_name_val and not re.match(r"^[a-zA-Z0-9]+$", app_name_val):
+            raise typer.BadParameter("--app-name must contain only letters and digits")
+
+
+_IMAGE_FIELDS = frozenset({"logoImg", "icoImg"})
+_ALLOWED_IMAGE_EXTENSIONS = frozenset({".jpg", ".jpeg", ".png"})
+_MAX_IMAGE_SIZE = 2 * 1024 * 1024
+
+
+def _image_to_base64(path: Path, field: str) -> str:
+    ext = path.suffix.lower()
+    if ext not in _ALLOWED_IMAGE_EXTENSIONS:
+        raise typer.BadParameter(
+            f"{field} in extConfig must be JPG/JPEG/PNG format (got {ext})"
+        )
+    size = path.stat().st_size
+    if size > _MAX_IMAGE_SIZE:
+        raise typer.BadParameter(
+            f"{field} in extConfig must not exceed 2MB (got {size / 1024 / 1024:.1f}MB)"
+        )
+    data = path.read_bytes()
+    b64_str = base64.b64encode(data).decode("ascii")
+    mime = "image/jpeg" if ext in (".jpg", ".jpeg") else "image/png"
+    return f"data:{mime};base64,{b64_str}"
+
+
+def _convert_image_file_paths(ext_dict: dict[str, Any]) -> None:
+    for field in _IMAGE_FIELDS:
+        val = ext_dict.get(field)
+        if isinstance(val, str) and not val.startswith("data:"):
+            p = Path(val)
+            if p.is_file():
+                ext_dict[field] = _image_to_base64(p, field)
+
+
+def _stringify_ext_config(payload: Any) -> None:
+    if isinstance(payload, dict):
+        for key, val in list(payload.items()):
+            if key == "extConfig" and isinstance(val, dict):
+                _convert_image_file_paths(val)
+                payload[key] = json_mod.dumps(val, ensure_ascii=False)
+            else:
+                _stringify_ext_config(val)
+    elif isinstance(payload, list):
+        for item in payload:
+            _stringify_ext_config(item)
+
+
+_OP_STRING_FIELDS = frozenset({"oprScript", "extSettings", "viewType"})
+
+
+def _stringify_op_fields(payload: dict[str, Any]) -> None:
+    for field in _OP_STRING_FIELDS:
+        val = payload.get(field)
+        if isinstance(val, dict):
+            payload[field] = json_mod.dumps(val, ensure_ascii=False)
+
+
+def _resolve_payload(data: str | None, data_file: Path | None) -> dict[str, Any]:
+    if data_file:
+        return json_mod.loads(data_file.read_text(encoding="utf-8"))
+    if data:
+        return json_mod.loads(data)
+    raise typer.BadParameter("Provide --data or --data-file")
+
+
+def _generate_app_name(title: str, app_type: str = "PC") -> str:
+    raw = app_type + "".join(pypinyin.lazy_pinyin(title, style=pypinyin.Style.NORMAL))
+    cleaned = re.sub(r"[^a-zA-Z0-9]", "", raw)
+    if len(cleaned) > 29:
+        cleaned = cleaned[:29]
+    suffix = "".join(
+        secrets.choice(string_mod.ascii_lowercase + string_mod.digits) for _ in range(3)
+    )
+    return cleaned + suffix
+
+
+# ── App Commands ───────────────────────────────────────────────────────
+
+
+@_app_sub.command(name="list")
+def list_apps(
+    ctx: typer.Context,
+    published_only: Annotated[
+        bool,
+        typer.Option("--published-only", help="Only show published apps"),
+    ] = False,
+    with_modeler_app: Annotated[
+        bool,
+        typer.Option(
+            "--with-modeler-app/--no-with-modeler-app", help="Include modeler app"
+        ),
+    ] = True,
+    with_ext_config: Annotated[
+        bool,
+        typer.Option(
+            "--with-ext-config/--no-with-ext-config", help="Include ext config"
+        ),
+    ] = True,
+    app_type: Annotated[
+        str | None,
+        typer.Option("--type", "-t", help="App type: PC, Mobile"),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.list_apps(
+            client,
+            published_only=published_only,
+            with_modeler_app=with_modeler_app,
+            with_ext_config=with_ext_config,
+            app_type=app_type,
+        )
+        items = _extract_items(result)
+        if not items:
+            if is_tty():
+                get_console().print("[dim]No apps found.[/dim]")
+            else:
+                typer.echo("[]")
+            return
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        _print_table(items, title="Applications")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="get")
+def get_app(
+    ctx: typer.Context,
+    name: Annotated[
+        str | None,
+        typer.Option("--name", "-n", help="App name (required if --id not given)"),
+    ] = None,
+    app_id: Annotated[
+        str | None,
+        typer.Option("--id", help="App ID (required if --name not given)"),
+    ] = None,
+    export: Annotated[
+        Path | None,
+        typer.Option(
+            "--export",
+            help="Export config to file for editing (then use with app update --data-file)",
+        ),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        if name and app_id:
+            raise typer.BadParameter("Use either --name OR --id, not both.")
+        if name:
+            result = funcmodel_api.get_app_by_name(client, name)
+        elif app_id:
+            result = funcmodel_api.get_app_by_id(client, app_id)
+        else:
+            raise typer.BadParameter(
+                "Provide one of: --name <app_name> or --id <app_id>"
+            )
+        if export:
+            data = result.get("data", result)
+            if isinstance(data.get("extConfig"), str):
+                try:
+                    data["extConfig"] = json_mod.loads(data["extConfig"])
+                except json_mod.JSONDecodeError:
+                    pass
+            export.write_text(
+                json_mod.dumps(data, ensure_ascii=False, indent=2),
+                encoding="utf-8",
+            )
+            get_console().print(f"[green]Config saved to {export}[/green]")
+            return
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        item = result.get("data", result)
+        if isinstance(item, dict):
+            _print_table([item], title="Application")
+        else:
+            typer.echo(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="create")
+def create_app(
+    ctx: typer.Context,
+    title: Annotated[
+        str | None,
+        typer.Option("--title", "-t", help="App title (Chinese name)"),
+    ] = None,
+    app_type: Annotated[
+        str,
+        typer.Option("--type", help="App type: PC or Mobile"),
+    ] = "PC",
+    app_name: Annotated[
+        str | None,
+        typer.Option(
+            "--app-name", "-n", help="App code name (auto-generated from title for PC)"
+        ),
+    ] = None,
+    data: Annotated[
+        str | None,
+        typer.Option(
+            "--data",
+            "-d",
+            help="Full app data as JSON string (alternative to individual options)",
+        ),
+    ] = None,
+    data_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--data-file",
+            help="JSON file path (alternative to --data)",
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if data is not None or data_file is not None:
+            raw = _resolve_data(data, data_file)
+            try:
+                parsed = json_mod.loads(raw)
+            except json_mod.JSONDecodeError as e:
+                Console().print(f"[red]Invalid JSON: {e}[/red]")
+                raise typer.Exit(code=2)
+            _stringify_ext_config(parsed)
+            _validate_create_params(parsed)
+        else:
+            if not title:
+                raise typer.BadParameter("--title is required when not using --data")
+            app_type_normalized = app_type.upper()
+            if app_type_normalized not in ("PC", "MOBILE"):
+                raise typer.BadParameter("--type must be 'PC' or 'Mobile'")
+            app_type = "PC" if app_type_normalized == "PC" else "Mobile"
+            if not app_name:
+                if app_type == "PC":
+                    app_name = _generate_app_name(title, app_type)
+                else:
+                    raise typer.BadParameter(
+                        "--app-name is required when --type is Mobile"
+                    )
+            parsed: dict[str, Any] = {
+                "title": title,
+                "type": app_type,
+                "appName": app_name,
+            }
+            _validate_create_params(parsed)
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "app",
+                        "target": parsed,
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.create_app(client, parsed)
+        raise_if_not_success(result, "Create app")
+        detail = parsed.get("appName") or parsed.get("title")
+        report_success(SuccessResult("Created", "app", detail=detail, data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="update")
+def update_app(
+    ctx: typer.Context,
+    title: Annotated[
+        str | None,
+        typer.Option("--title", "-t", help="App title (Chinese name)"),
+    ] = None,
+    app_name: Annotated[
+        str | None,
+        typer.Option("--app-name", "-n", help="App code name"),
+    ] = None,
+    data: Annotated[
+        str | None,
+        typer.Option(
+            "--data",
+            "-d",
+            help="Full app data as JSON string (alternative to individual options)",
+        ),
+    ] = None,
+    data_file: Annotated[
+        Path | None,
+        typer.Option(
+            "--data-file",
+            help="JSON file path (alternative to --data)",
+        ),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if data is not None or data_file is not None:
+            raw = _resolve_data(data, data_file)
+            try:
+                parsed = json_mod.loads(raw)
+            except json_mod.JSONDecodeError as e:
+                Console().print(f"[red]Invalid JSON: {e}[/red]")
+                raise typer.Exit(code=2)
+            _stringify_ext_config(parsed)
+            _validate_create_params(parsed)
+        else:
+            parsed: dict[str, Any] = {}
+            if title:
+                parsed["title"] = title
+            if app_name:
+                parsed["appName"] = app_name
+            if not parsed:
+                raise typer.BadParameter(
+                    "Provide at least one of: --title, --app-name, or use --data/--data-file"
+                )
+            _validate_create_params(parsed)
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update",
+                        "resource": "app",
+                        "target": parsed,
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.update_app(client, parsed)
+        raise_if_not_success(result, "Update app")
+        detail = parsed.get("appName")
+        report_success(SuccessResult("Updated", "app", detail=detail, data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="delete")
+def delete_app(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID to delete")],
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Confirm deletion"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "app",
+                        "target": {"app_id": app_id},
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        if not yes and is_tty():
+            confirmed = typer.confirm(f"Delete app '{app_id}'?")
+            if not confirmed:
+                raise typer.Exit(code=0)
+        client = get_client(ctx)
+        result = funcmodel_api.delete_app(client, app_id)
+        raise_if_not_success(result, "Delete app")
+        report_success(SuccessResult("Deleted", "app", detail=app_id, data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="set-default")
+def set_default_app(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    set_default: Annotated[
+        bool,
+        typer.Option("--set-default/--unset-default", help="Set or unset as default"),
+    ] = True,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "set_default",
+                        "resource": "app",
+                        "target": {"app_id": app_id, "set_default": set_default},
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.set_default_app(client, app_id, set_default)
+        raise_if_not_success(result, "Set default app")
+        action_label = "Set as default" if set_default else "Unset as default"
+        report_success(
+            SuccessResult(action_label, "app", detail=app_id, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="publish")
+def publish_app(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    publish: Annotated[
+        bool,
+        typer.Option("--publish/--unpublish", help="Publish or unpublish"),
+    ] = True,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "publish" if publish else "unpublish",
+                        "resource": "app",
+                        "target": {"app_id": app_id},
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.publish_app(client, app_id, publish)
+        raise_if_not_success(result, "Publish app")
+        action_label = "Published" if publish else "Unpublished"
+        report_success(
+            SuccessResult(action_label, "app", detail=app_id, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="get-default")
+def get_default_app(
+    ctx: typer.Context,
+    app_type: Annotated[str, typer.Argument(help="App type: PC or Mobile")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_default_app_by_type(client, app_type)
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        item = result.get("data", result)
+        if isinstance(item, dict):
+            _print_table([item], title=f"Default {app_type} App")
+        else:
+            typer.echo(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="reset-modeler")
+def reset_modeler_menus(
+    ctx: typer.Context,
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Confirm reset"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "reset",
+                        "resource": "modeler_menus",
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        if not yes and is_tty():
+            confirmed = typer.confirm("Reset all modeler menus?")
+            if not confirmed:
+                raise typer.Exit(code=0)
+        client = get_client(ctx)
+        result = funcmodel_api.reset_modeler_menus(client)
+        raise_if_not_success(result, "Reset modeler menus")
+        report_success(SuccessResult("Reset", "modeler menus", data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="upload-logo")
+def upload_logo(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="Logo file path")],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "upload_logo",
+                        "resource": "app",
+                        "target": {"app_id": app_id, "file": str(file)},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.upload_logo(client, app_id, file)
+        raise_if_not_success(result, "Upload logo")
+        report_success(
+            SuccessResult("Uploaded", "logo", detail=app_id, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="upload-icon")
+def upload_icon(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="Icon file path")],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "upload_icon",
+                        "resource": "app",
+                        "target": {"app_id": app_id, "file": str(file)},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.upload_icon(client, app_id, file)
+        raise_if_not_success(result, "Upload icon")
+        report_success(
+            SuccessResult("Uploaded", "icon", detail=app_id, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="get-logo")
+def get_logo(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    output: Annotated[Path, typer.Option("--output", "-o", help="Output file path")],
+) -> None:
+    try:
+        client = get_client(ctx)
+        response = funcmodel_api.get_logo(client, app_id)
+        with open(output, "wb") as f:
+            f.write(response.content)
+        Console().print(f"[green]Logo saved to {output}[/green]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="get-logo-base64")
+def get_logo_base64(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    img_type: Annotated[
+        str,
+        typer.Option("--img-type", help="Image keyword: logoImg, iconImg"),
+    ] = "logoImg",
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_logo_base64(client, app_id, img_type=img_type)
+        fmt = resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_app_sub.command(name="get-css")
+def get_css(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    output: Annotated[Path, typer.Option("--output", "-o", help="Output file path")],
+) -> None:
+    try:
+        client = get_client(ctx)
+        response = funcmodel_api.get_css_file(client, app_id)
+        with open(output, "wb") as f:
+            f.write(response.content)
+        Console().print(f"[green]CSS file saved to {output}[/green]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Theme Commands ─────────────────────────────────────────────────────
+
+
+@_theme_sub.command(name="list")
+def list_themes(
+    ctx: typer.Context,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.list_themes(client)
+        items = _extract_items(result)
+        if not items:
+            if is_tty():
+                Console().print("[dim]No themes found.[/dim]")
+            else:
+                typer.echo("[]")
+            return
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        _print_table(items, title="Themes")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_theme_sub.command(name="create")
+def create_theme(
+    ctx: typer.Context,
+    theme_name: Annotated[str, typer.Option("--name", "-n", help="Theme name")],
+    file: Annotated[Path, typer.Option("--file", help="Theme CSS file path")],
+    note: Annotated[str | None, typer.Option("--note", help="Theme note")] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "theme",
+                        "target": {"theme_name": theme_name, "note": note},
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.create_theme(
+            client, theme_name=theme_name, note=note, file_path=file
+        )
+        raise_if_not_success(result, "Create theme")
+        report_success(
+            SuccessResult("Created", "theme", detail=theme_name, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_theme_sub.command(name="update")
+def update_theme(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Theme OID")],
+    theme_name: Annotated[
+        str | None, typer.Option("--name", "-n", help="Theme name")
+    ] = None,
+    note: Annotated[str | None, typer.Option("--note", help="Theme note")] = None,
+    file: Annotated[
+        Path | None, typer.Option("--file", "-f", help="Theme CSS file path")
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update",
+                        "resource": "theme",
+                        "target": {"oid": oid},
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.update_theme(
+            client, oid, theme_name=theme_name, note=note, file_path=file
+        )
+        raise_if_not_success(result, "Update theme")
+        report_success(SuccessResult("Updated", "theme", detail=oid, data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_theme_sub.command(name="delete")
+def delete_theme(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Theme OID")],
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Confirm deletion"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "theme",
+                        "target": {"oid": oid},
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        if not yes and is_tty():
+            confirmed = typer.confirm(f"Delete theme '{oid}'?")
+            if not confirmed:
+                raise typer.Exit(code=0)
+        client = get_client(ctx)
+        result = funcmodel_api.delete_theme(client, oid)
+        raise_if_not_success(result, "Delete theme")
+        report_success(SuccessResult("Deleted", "theme", detail=oid, data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Language Package Commands ──────────────────────────────────────────
+
+
+@_lang_pkg_sub.command(name="list")
+def list_language_packages(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Option("--app-id", help="App ID")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.list_language_packages(client, app_id)
+        items = _extract_items(result)
+        if not items:
+            if is_tty():
+                Console().print("[dim]No language packages found.[/dim]")
+            else:
+                typer.echo("[]")
+            return
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        _print_table(items, title=f"Language Packages (app: {app_id})")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="get")
+def get_language_package(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Option("--app-id", help="App ID")],
+    language: Annotated[str, typer.Option("--language", "-l", help="Language code")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_language_package_by_language(
+            client, app_id, language
+        )
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        item = result.get("data", result)
+        if isinstance(item, dict):
+            _print_table([item], title=f"Language Package ({language})")
+        else:
+            typer.echo(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="get-json")
+def get_language_package_json(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Option("--app-id", help="App ID")],
+    language: Annotated[str, typer.Option("--language", "-l", help="Language code")],
+    is_frontend: Annotated[
+        bool,
+        typer.Option("--is-frontend/--not-frontend", help="Is frontend config file"),
+    ] = True,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_language_package_json(
+            client, app_id, language, is_frontend=is_frontend
+        )
+        fmt = resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="get-file")
+def get_language_package_file(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Option("--app-id", help="App ID")],
+    language: Annotated[str, typer.Option("--language", "-l", help="Language code")],
+    output: Annotated[Path, typer.Option("--output", "-o", help="Output file path")],
+) -> None:
+    try:
+        client = get_client(ctx)
+        response = funcmodel_api.get_language_package_file(client, app_id, language)
+        with open(output, "wb") as f:
+            f.write(response.content)
+        Console().print(f"[green]File saved to {output}[/green]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="create")
+def create_language_package(
+    ctx: typer.Context,
+    app_language_package_do: Annotated[
+        str,
+        typer.Option("--data", "-d", help="Language package DO JSON string"),
+    ],
+    file: Annotated[Path, typer.Option("--file", "-f", help="Language package file")],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "create",
+                        "resource": "language_package",
+                        "target": {"data": app_language_package_do, "file": str(file)},
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.create_language_package(
+            client, app_language_package_do, file
+        )
+        raise_if_not_success(result, "Create language package")
+        report_success(SuccessResult("Created", "language package", data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="update")
+def update_language_package(
+    ctx: typer.Context,
+    package_id: Annotated[str, typer.Argument(help="Language package ID")],
+    file: Annotated[Path, typer.Option("--file", "-f", help="Language package file")],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update",
+                        "resource": "language_package",
+                        "target": {"package_id": package_id, "file": str(file)},
+                        "reversible": True,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.update_language_package(client, package_id, file)
+        raise_if_not_success(result, "Update language package")
+        report_success(
+            SuccessResult(
+                "Updated", "language package", detail=package_id, data=result
+            ),
+            fmt,
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="delete")
+def delete_language_package(
+    ctx: typer.Context,
+    package_id: Annotated[str, typer.Argument(help="Language package ID")],
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Confirm deletion"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "language_package",
+                        "target": {"package_id": package_id},
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        if not yes and is_tty():
+            confirmed = typer.confirm(f"Delete language package '{package_id}'?")
+            if not confirmed:
+                raise typer.Exit(code=0)
+        client = get_client(ctx)
+        result = funcmodel_api.delete_language_package(client, package_id)
+        raise_if_not_success(result, "Delete language package")
+        report_success(
+            SuccessResult(
+                "Deleted", "language package", detail=package_id, data=result
+            ),
+            fmt,
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="delete-by-app")
+def delete_language_packages_by_app(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    yes: Annotated[
+        bool,
+        typer.Option("--yes", "-y", help="Confirm deletion"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete_by_app",
+                        "resource": "language_package",
+                        "target": {"app_id": app_id},
+                        "reversible": False,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        if not yes and is_tty():
+            confirmed = typer.confirm(
+                f"Delete all language packages for app '{app_id}'?"
+            )
+            if not confirmed:
+                raise typer.Exit(code=0)
+        client = get_client(ctx)
+        result = funcmodel_api.delete_language_packages_by_app(client, app_id)
+        raise_if_not_success(result, "Delete language packages by app")
+        report_success(
+            SuccessResult(
+                "Deleted", "language packages", detail=f"app '{app_id}'", data=result
+            ),
+            fmt,
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="types")
+def list_supported_language_types(
+    ctx: typer.Context,
+    mobile_only: Annotated[
+        bool,
+        typer.Option(
+            "--mobile-only/--no-mobile-only", help="Only mobile supported types"
+        ),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_supported_language_types(
+            client, mobile_only=mobile_only
+        )
+        fmt = resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="get-template")
+def get_language_package_template(
+    ctx: typer.Context,
+    output: Annotated[Path, typer.Option("--output", "-o", help="Output file path")],
+    template_type: Annotated[
+        str,
+        typer.Option("--type", "-t", help="Template type: PC, Mobile"),
+    ] = "PC",
+) -> None:
+    try:
+        client = get_client(ctx)
+        response = funcmodel_api.get_language_package_template_file(
+            client, template_type
+        )
+        with open(output, "wb") as f:
+            f.write(response.content)
+        Console().print(f"[green]Template saved to {output}[/green]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_lang_pkg_sub.command(name="get-template-json")
+def get_language_package_template_json(
+    ctx: typer.Context,
+    template_type: Annotated[
+        str,
+        typer.Option("--type", "-t", help="Template type: PC, Mobile"),
+    ] = "PC",
+    second_key: Annotated[
+        str | None,
+        typer.Option("--second-key", help="Second level key under zh_CN"),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_language_package_template_json(
+            client, template_type=template_type, second_key=second_key
+        )
+        fmt = resolve_format(fmt)
+        typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Operations Commands ────────────────────────────────────────────────
+
+
+@_operations_sub.command(name="list")
+def list_operations(
+    ctx: typer.Context,
+    operation_type: Annotated[
+        OperationType,
+        typer.Option(
+            "--type",
+            "-t",
+            help="Operation type: global, entity, relation",
+            case_sensitive=False,
+        ),
+    ] = OperationType.global_,
+    page: Annotated[int, typer.Option("--page", "-p", help="Page index (0-based)")] = 0,
+    page_size: Annotated[
+        int, typer.Option("--page-size", "-s", help="Items per page")
+    ] = 25,
+    page_all: Annotated[
+        bool,
+        typer.Option("--page-all", help="Fetch all pages automatically"),
+    ] = False,
+    fuzzy_search: Annotated[
+        str | None,
+        typer.Option("--search", help="Fuzzy search keyword"),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        if page_all:
+            all_items: list[dict[str, Any]] = []
+            page_idx = 0
+            while True:
+                r = funcmodel_api.list_operations(
+                    client,
+                    operation_type.value,
+                    page=page_idx,
+                    page_size=page_size,
+                    fuzzy_search=fuzzy_search,
+                )
+                p_items = _extract_items(r)
+                all_items.extend(p_items)
+                p_info = _extract_page_info(r)
+                total = p_info.get("totalCount", 0) if p_info else 0
+                if not p_items or (total > 0 and len(all_items) >= total):
+                    break
+                page_idx += 1
+            items = all_items
+            page_info = {
+                "totalCount": len(all_items),
+                "pageIndex": 0,
+                "pageSize": len(all_items),
+            }
+        else:
+            result = funcmodel_api.list_operations(
+                client,
+                operation_type.value,
+                page=page,
+                page_size=page_size,
+                fuzzy_search=fuzzy_search,
+            )
+            items = _extract_items(result)
+            page_info = _extract_page_info(result)
+
+        if not items:
+            if is_tty():
+                get_console().print("[dim]No operations found.[/dim]")
+            else:
+                typer.echo("[]")
+            return
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            if page_all:
+                typer.echo(
+                    json_mod.dumps(
+                        {"data": items, "pageInfo": page_info},
+                        ensure_ascii=False,
+                        indent=2,
+                    )
+                )
+            else:
+                typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        flat_items = _flatten_operations(items)
+        _print_table(
+            flat_items,
+            title=f"Operations ({operation_type.value})",
+            page_info=page_info,
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="all")
+def list_all_operations(
+    ctx: typer.Context,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_all_operations(client)
+        items = result.get("data", result)
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        if isinstance(items, dict):
+            _print_table([items], title="All Operations")
+        else:
+            get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="keywords")
+def get_operation_keywords(
+    ctx: typer.Context,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_operation_keywords(client)
+        items = result.get("data", result)
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        if isinstance(items, list):
+            for kw in items:
+                get_console().print(kw)
+        else:
+            get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="get")
+def get_operation(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Operation ID")],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_operation_by_id(client, oid)
+        item = result.get("data", result)
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        if isinstance(item, dict):
+            _print_table([item], title=f"Operation ({oid})")
+        else:
+            get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="get-by-ids")
+def get_operations_by_ids(
+    ctx: typer.Context,
+    ids: Annotated[
+        list[str],
+        typer.Option("--id", help="Operation ID (repeatable)"),
+    ],
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_operations_by_ids(client, ids)
+        items = result.get("data", result)
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        if isinstance(items, dict):
+            flat = (
+                [{"id": k, **v} for k, v in items.items()]
+                if isinstance(items, dict)
+                else items
+            )
+            _print_table(flat, title="Operations")
+        else:
+            get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="create")
+def create_operation(
+    ctx: typer.Context,
+    data: Annotated[
+        str | None,
+        typer.Option("--data", "-d", help="Operation data as JSON string"),
+    ] = None,
+    data_file: Annotated[
+        Path | None,
+        typer.Option("--data-file", help="JSON file path (alternative to --data)"),
+    ] = None,
+    auto_generate_name: Annotated[
+        bool,
+        typer.Option("--auto-name", help="Auto-generate operation name"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        try:
+            parsed = _resolve_payload(data, data_file)
+            _stringify_op_fields(parsed)
+        except json_mod.JSONDecodeError as e:
+            get_console().print(f"[red]Invalid JSON: {e}[/red]")
+            raise typer.Exit(code=2)
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {"action": "create", "resource": "operation", "target": parsed},
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.create_operation(
+            client, parsed, auto_generate_name=auto_generate_name
+        )
+        raise_if_not_success(result, "Create operation")
+        report_success(SuccessResult("Created", "operation", data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="update")
+def update_operation(
+    ctx: typer.Context,
+    data: Annotated[
+        str | None,
+        typer.Option("--data", "-d", help="Operation data as JSON string"),
+    ] = None,
+    data_file: Annotated[
+        Path | None,
+        typer.Option("--data-file", help="JSON file path (alternative to --data)"),
+    ] = None,
+    force_update: Annotated[
+        bool,
+        typer.Option("--force", help="Force update"),
+    ] = False,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        try:
+            parsed = _resolve_payload(data, data_file)
+            _stringify_op_fields(parsed)
+        except json_mod.JSONDecodeError as e:
+            get_console().print(f"[red]Invalid JSON: {e}[/red]")
+            raise typer.Exit(code=2)
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {"action": "update", "resource": "operation", "target": parsed},
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.update_operation(
+            client, parsed, force_update=force_update
+        )
+        raise_if_not_success(result, "Update operation")
+        report_success(SuccessResult("Updated", "operation", data=result), fmt)
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="delete")
+def delete_operation(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Operation ID")],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "delete",
+                        "resource": "operation",
+                        "target": {"id": oid},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.delete_operation(client, oid)
+        raise_if_not_success(result, "Delete operation")
+        report_success(
+            SuccessResult("Deleted", "operation", detail=oid, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="move")
+def move_operation(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Operation ID to move")],
+    parent_id: Annotated[
+        str, typer.Option("--parent-id", help="Target parent operation/module class ID")
+    ],
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "move",
+                        "resource": "operation",
+                        "target": {"id": oid, "parentId": parent_id},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.move_operation(client, oid, parent_id)
+        raise_if_not_success(result, "Move operation")
+        report_success(
+            SuccessResult("Moved", "operation", detail=oid, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="hide")
+def hide_operation(
+    ctx: typer.Context,
+    oid: Annotated[str, typer.Argument(help="Operation ID")],
+    hide: Annotated[
+        bool, typer.Option("--hide/--show", help="Hide or show the operation")
+    ] = True,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "hide" if hide else "show",
+                        "resource": "operation",
+                        "target": {"id": oid},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.hide_operation(client, oid, hide)
+        raise_if_not_success(result, "Hide operation")
+        action_label = "Hidden" if hide else "Shown"
+        report_success(
+            SuccessResult(action_label, "operation", detail=oid, data=result), fmt
+        )
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="check-name")
+def check_operation_display_name(
+    ctx: typer.Context,
+    data: Annotated[
+        str | None,
+        typer.Option(
+            "--data", "-d", help="Operation data as JSON string for display name check"
+        ),
+    ] = None,
+    data_file: Annotated[
+        Path | None,
+        typer.Option("--data-file", help="JSON file path (alternative to --data)"),
+    ] = None,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        try:
+            parsed = _resolve_payload(data, data_file)
+        except json_mod.JSONDecodeError as e:
+            get_console().print(f"[red]Invalid JSON: {e}[/red]")
+            raise typer.Exit(code=2)
+        client = get_client(ctx)
+        result = funcmodel_api.check_operation_display_name(client, parsed)
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        items = result.get("data", result)
+        if isinstance(items, list):
+            _print_table(items, title="Display Name Check Results")
+        else:
+            get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_operations_sub.command(name="global-scripts")
+def get_global_implement_scripts(
+    ctx: typer.Context,
+    is_client_script: Annotated[
+        bool,
+        typer.Option("--client/--server", help="Client-side or server-side script"),
+    ] = True,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_global_implement_scripts(
+            client, is_client_script=is_client_script
+        )
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+# ── Modules Commands ────────────────────────────────────────────────────
+
+
+@_modules_sub.command(name="list")
+def list_modules(
+    ctx: typer.Context,
+    app_id: Annotated[
+        str | None,
+        typer.Option("--app-id", help="App OID (default app if not specified)"),
+    ] = None,
+    with_default_module: Annotated[
+        bool,
+        typer.Option("--with-default", help="Include default module"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.list_modules(
+            client, app_id=app_id, with_default_module=with_default_module
+        )
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        data = result.get("data", result)
+        if isinstance(data, list) and data:
+            _print_table(data, title="Modules")
+        else:
+            get_console().print("[dim]No modules found.[/dim]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_modules_sub.command(name="tree")
+def modules_tree(
+    ctx: typer.Context,
+    app_id: Annotated[
+        str | None,
+        typer.Option("--app-id", help="App OID (all apps if not specified)"),
+    ] = None,
+    with_default_module: Annotated[
+        bool,
+        typer.Option("--with-default", help="Include default module"),
+    ] = False,
+    published_only: Annotated[
+        bool,
+        typer.Option("--published-only/--all", help="Only published apps"),
+    ] = True,
+    with_hidden: Annotated[
+        bool,
+        typer.Option("--with-hidden", help="Include hidden operations"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_modules_operations_tree(
+            client,
+            app_id=app_id,
+            with_default_module=with_default_module,
+            published_only=published_only,
+            with_hidden=with_hidden,
+        )
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        get_console().print(str(result))
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_modules_sub.command(name="operations")
+def module_operations(
+    ctx: typer.Context,
+    module_name: Annotated[str, typer.Argument(help="Module class name")],
+    with_hidden: Annotated[
+        bool,
+        typer.Option("--with-hidden", help="Include hidden operations"),
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        client = get_client(ctx)
+        result = funcmodel_api.get_module_operations(
+            client, module_name, with_hidden=with_hidden
+        )
+        fmt = resolve_format(fmt)
+        if fmt == OutputFormat.json:
+            typer.echo(json_mod.dumps(result, ensure_ascii=False, indent=2))
+            return
+        inner = result.get("data", result)
+        ops = inner.get("queryOprConfigs", inner) if isinstance(inner, dict) else inner
+        if isinstance(ops, list) and ops:
+            _print_table(ops, title=f"Module Operations ({module_name})")
+        else:
+            get_console().print("[dim]No operations found.[/dim]")
+    except DWFError as exc:
+        handle_error(exc)
+
+
+@_modules_sub.command(name="update-order")
+def update_modules_order(
+    ctx: typer.Context,
+    app_id: Annotated[str, typer.Argument(help="App ID")],
+    data: Annotated[
+        str | None,
+        typer.Option("--data", "-d", help="Tree data as JSON string"),
+    ] = None,
+    data_file: Annotated[
+        Path | None,
+        typer.Option("--data-file", help="JSON file path"),
+    ] = None,
+    dry_run: Annotated[
+        bool, typer.Option("--dry-run", help="Preview without executing")
+    ] = False,
+    fmt: Annotated[
+        OutputFormat,
+        typer.Option("--format", "-f", help="Output format: table/json"),
+    ] = OutputFormat.table,
+) -> None:
+    try:
+        try:
+            if data_file:
+                tree = json_mod.loads(data_file.read_text(encoding="utf-8"))
+            elif data:
+                tree = json_mod.loads(data)
+            else:
+                raise typer.BadParameter("Provide --data or --data-file")
+        except json_mod.JSONDecodeError as e:
+            get_console().print(f"[red]Invalid JSON: {e}[/red]")
+            raise typer.Exit(code=2)
+        if dry_run:
+            typer.echo(
+                json_mod.dumps(
+                    {
+                        "action": "update-order",
+                        "resource": "modules-tree",
+                        "target": {"appId": app_id, "tree": tree},
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            )
+            raise typer.Exit(code=10)
+        client = get_client(ctx)
+        result = funcmodel_api.update_modules_tree_order(client, app_id, tree)
+        raise_if_not_success(result, "Update modules tree order")
+        report_success(
+            SuccessResult("Updated", "modules tree order", detail=app_id, data=result),
+            fmt,
+        )
+    except DWFError as exc:
+        handle_error(exc)