hap-cli 0.8.0__tar.gz → 0.8.2__tar.gz

{hap_cli-0.8.0 → hap_cli-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hap-cli
-Version: 0.8.0
+Version: 0.8.2
 Summary: CLI harness for MingDAO HAP - Enterprise no-code platform
 Author: hap-cli
 License: Apache-2.0

{hap_cli-0.8.0 → hap_cli-0.8.2}/app_live_tests/smoke.py

@@ -1,16 +1,21 @@
-"""Live smoke scenarios for the editor, run against the persistent app.
-
-Each scenario drives the real editor entry point and asserts the result
-by reading back through ``hap``. Scenarios create their own worksheet and
-delete it at the end, so the persistent app stays clean and the suite is
-re-runnable. Run: ``python3 -m app_live_tests smoke [--case NAME]``.
+"""Live smoke scenarios for the editor + bare CLI, run against the persistent app.
+
+Edit-spec scenarios (field/component/custom-action) drive the real editor
+entry point; everything else uses the bare ``hap`` commands that replaced
+the retired edit-spec ops. Each scenario asserts the result by reading back
+through ``hap``. Scenarios create their own worksheet and delete it at the
+end, so the persistent app stays clean and the suite is re-runnable.
+Run: ``python3 -m app_live_tests smoke [--case NAME]``.
 """
 from __future__ import annotations
 
+import json
 import sys
+import tempfile
+from pathlib import Path
 
 from app_live_tests import state
-from app_live_tests.harness import editor_apply, hap
+from app_live_tests.harness import editor, editor_apply, hap
 
 _failures: list[str] = []
 
@@ -23,6 +28,14 @@ def check(name: str, cond: bool, detail: str = "") -> None:
         print(f"  FAIL {name}: {detail}")
 
 
+def _try(args: list[str]) -> tuple[bool, object]:
+    """Run a bare ``hap`` command; return (ok, payload-or-error-text)."""
+    try:
+        return True, hap(args)
+    except RuntimeError as e:
+        return False, str(e)
+
+
 # ── helpers ──────────────────────────────────────────────────────────────
 def _worksheets(app_id: str) -> dict[str, str]:
     detail = hap(["app", "info", "-a", app_id])
@@ -48,7 +61,7 @@ def _ensure_absent(app_id: str, name: str) -> None:
     """Delete a leftover worksheet of this name (from a crashed prior run)."""
     ws = _worksheets(app_id)
     if name in ws:
-        hap(["worksheet", "delete", ws[name], "-a", app_id], check=False)
+        hap(["worksheet", "delete", ws[name], "-a", app_id, "-y"], check=False)
 
 
 def _make_worksheet(app_id: str, section_id: str, name: str) -> str:
@@ -59,19 +72,18 @@ def _make_worksheet(app_id: str, section_id: str, name: str) -> str:
 
 # ── scenarios ──────────────────────────────────────────────────────────────
 def case_worksheet(app_id: str, section_id: str) -> None:
-    print("scenario: worksheet create/update/delete")
+    print("scenario: worksheet create/update/delete (bare commands)")
     name = "LT-ws"
     _ensure_absent(app_id, name)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "worksheet.create", "name": name},
-        {"type": "worksheet.update", "worksheet": name, "desc": "live test"},
-    ]})
-    check("apply create+update succeeds", rc == 0, err or out)
+    ok, res = _try(["worksheet", "create", app_id, name,
+                    "--section-id", section_id])
+    ws_id = res.get("workSheetId") if isinstance(res, dict) else ""
+    check("worksheet create succeeds", ok and bool(ws_id), str(res))
+    ok, res = _try(["worksheet", "update", ws_id, "--desc", "live test"])
+    check("worksheet update succeeds", ok, str(res))
     check("worksheet exists after create", name in _worksheets(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "worksheet.delete", "worksheet": name, "confirm": True},
-    ]})
-    check("apply delete succeeds", rc == 0, err or out)
+    ok, res = _try(["worksheet", "delete", ws_id, "-a", app_id, "-y"])
+    check("worksheet delete succeeds", ok, str(res))
     check("worksheet gone after delete", name not in _worksheets(app_id))
 
 
@@ -113,31 +125,32 @@ def case_field(app_id: str, section_id: str) -> None:
     rows = [(c["controlName"], c.get("row")) for c in _fields(ws_id)]
     first = min(rows, key=lambda t: (t[1] if t[1] is not None else 9999))
     check("reordered field is first", first[0] == "金额", str(rows))
-    hap(["worksheet", "delete", ws_id, "-a", app_id], check=False)
+    hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
 
 
 def case_view(app_id: str, section_id: str) -> None:
-    print("scenario: view create/update/delete")
+    print("scenario: view create/update/delete (bare commands)")
     name = "LT-views"
     ws_id = _make_worksheet(app_id, section_id, name)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "view.create", "worksheet": name, "name": "按状态",
-         "view_type": "board"},
-        {"type": "view.update", "worksheet": name, "view": "按状态",
-         "name": "看板", "edit_attrs": ["name"]},
-    ]})
-    check("apply view create+update succeeds", rc == 0, err or out)
+    ok, res = _try(["worksheet", "view", "create", ws_id, "按状态",
+                    "--view-type", "board", "-a", app_id])
+    check("view create succeeds", ok, str(res))
+    view = next((v for v in _views(ws_id) if v.get("name") == "按状态"), {})
+    view_id = view.get("viewId") or view.get("id")
+    check("view present after create", bool(view_id),
+          str({v.get("name") for v in _views(ws_id)}))
+    ok, res = _try(["worksheet", "view", "update", ws_id, view_id,
+                    "--name", "看板", "-a", app_id])
+    check("view update (rename) succeeds", ok, str(res))
     names = {v.get("name") for v in _views(ws_id)}
     check("view renamed to 看板", "看板" in names and "按状态" not in names,
           str(names))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "view.delete", "worksheet": name, "view": "看板",
-         "confirm": True},
-    ]})
-    check("apply view delete succeeds", rc == 0, err or out)
+    ok, res = _try(["worksheet", "view", "delete", ws_id, view_id,
+                    "-a", app_id, "-y"])
+    check("view delete succeeds", ok, str(res))
     names = {v.get("name") for v in _views(ws_id)}
     check("view gone after delete", "看板" not in names, str(names))
-    hap(["worksheet", "delete", ws_id, "-a", app_id], check=False)
+    hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
 
 
 def _roles(app_id: str) -> dict[str, str]:
@@ -153,32 +166,28 @@ def case_role(app_id: str, section_id: str) -> None:
     existing = _roles(app_id)
     for n in (name, renamed):
         if n in existing:
-            hap(["app", "role", "delete", existing[n], "-a", app_id], check=False)
+            hap(["app", "role", "delete", existing[n], "-a", app_id, "-y"], check=False)
     who = hap(["auth", "whoami"])
     me = who.get("id") if isinstance(who, dict) else ""
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "role.create", "name": name, "description": "live test role"},
-    ]})
-    check("apply role.create succeeds", rc == 0, err or out)
+    ok, res = _try(["app", "role", "create", "--name", name,
+                    "--description", "live test role", "--type", "0",
+                    "--permission-scope", "80", "-a", app_id])
+    check("role create succeeds", ok, str(res))
     check("role exists after create", name in _roles(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "role.update", "role": name, "rename": renamed},
-    ]})
-    check("apply role.update rename succeeds", rc == 0, err or out)
+    role_id = _roles(app_id).get(name, "")
+    ok, res = _try(["app", "role", "rename", app_id, role_id, "-n", renamed])
+    check("role rename succeeds", ok, str(res))
     check("role renamed", renamed in _roles(app_id) and name not in _roles(app_id))
-    current = renamed if renamed in _roles(app_id) else name
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "role.add_member", "role": current,
-         "members": {"user_ids": [me]}},
-        {"type": "role.remove_member", "role": current,
-         "members": {"user_ids": [me]}},
-    ]})
-    check("apply role member add+remove succeed", rc == 0, err or out)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "role.delete", "role": current, "confirm": True},
-    ]})
-    check("apply role.delete succeeds", rc == 0, err or out)
-    check("role gone after delete", current not in _roles(app_id))
+    current_id = _roles(app_id).get(renamed) or role_id
+    ok, res = _try(["app", "role", "add-member", current_id,
+                    "--user-ids", me, "-a", app_id])
+    check("role add-member succeeds", ok, str(res))
+    ok, res = _try(["app", "role", "remove-member", current_id,
+                    "--user-ids", me, "-a", app_id])
+    check("role remove-member succeeds", ok, str(res))
+    ok, res = _try(["app", "role", "delete", current_id, "-a", app_id, "-y"])
+    check("role delete succeeds", ok, str(res))
+    check("role gone after delete", renamed not in _roles(app_id))
 
 
 def _actions(ws_id: str) -> list[dict]:
@@ -205,14 +214,14 @@ def case_custom_action(app_id: str, section_id: str) -> None:
     btn = next((b for b in _actions(ws_id) if b.get("name") == "标记"), {})
     btn_ref = btn.get("btnId") or btn.get("id")
     if btn_ref:
-        rc, out, err = editor_apply({"app": app_id, "ops": [
-            {"type": "custom-action.delete", "worksheet": name,
-             "action": btn_ref, "confirm": True},
-        ]})
-        check("apply custom-action.delete succeeds", rc == 0, err or out)
+        # custom-action.delete is retired from the edit-spec; use the bare
+        # command instead.
+        ok, res = _try(["worksheet", "delete-custom-action", ws_id, btn_ref,
+                        "-a", app_id, "-y"])
+        check("delete-custom-action succeeds", ok, str(res))
         names = {b.get("name") for b in _actions(ws_id)}
         check("custom action gone after delete", "标记" not in names, str(names))
-    hap(["worksheet", "delete", ws_id, "-a", app_id], check=False)
+    hap(["worksheet", "delete", ws_id, "-a", app_id, "-y"], check=False)
 
 
 def _items(app_id: str) -> dict[str, str]:
@@ -233,68 +242,80 @@ def _workflow_names(app_id: str) -> set[str]:
 
 
 def case_chatbot(app_id: str, section_id: str) -> None:
-    print("scenario: chatbot create/update/delete")
+    print("scenario: chatbot create/update/delete (bare commands)")
     name = "LT-bot"
+    # NOTE: --permanent is a silent server-side no-op for chatbots (returns
+    # true but the item stays); recycle-bin delete actually removes it.
     if name in _items(app_id):
-        hap(["worksheet", "delete", _items(app_id)[name], "-a", app_id], check=False)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "chatbot.create", "name": name, "prompt": "你是测试助手"},
-    ]})
-    check("apply chatbot.create succeeds", rc == 0, err or out)
+        hap(["app", "chatbot", "delete", _items(app_id)[name], "-a", app_id,
+             "--section-id", section_id, "-y"], check=False)
+    ok, res = _try(["app", "chatbot", "create", app_id, name,
+                    "--section-id", section_id, "--prompt", "你是测试助手"])
+    check("chatbot create succeeds", ok, str(res))
     check("chatbot present after create", name in _items(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "chatbot.update", "chatbot": name, "welcome_text": "你好"},
-        {"type": "chatbot.delete", "chatbot": name, "confirm": True},
-    ]})
-    check("apply chatbot.update+delete succeed", rc == 0, err or out)
+    bot_id = _items(app_id).get(name, "")
+    ok, res = _try(["app", "chatbot", "update-config", bot_id,
+                    "--welcome-text", "你好"])
+    check("chatbot update-config succeeds", ok, str(res))
+    ok, res = _try(["app", "chatbot", "delete", bot_id, "-a", app_id,
+                    "--section-id", section_id, "-y"])
+    check("chatbot delete succeeds", ok, str(res))
     check("chatbot gone after delete", name not in _items(app_id))
 
 
 def case_custom_page(app_id: str, section_id: str) -> None:
-    print("scenario: custom-page create/update/delete")
+    print("scenario: custom-page create/rename/delete (bare commands)")
     name, renamed = "LT-page", "LT-page-2"
     items = _items(app_id)
     for n in (name, renamed):
         if n in items:
             hap(["custom-page", "delete", app_id, items[n],
                  "--section-id", section_id, "--yes"], check=False)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "custom-page.create", "name": name},
-    ]})
-    check("apply custom-page.create succeeds", rc == 0, err or out)
+    ok, res = _try(["custom-page", "create", app_id, name,
+                    "--section-id", section_id])
+    check("custom-page create succeeds", ok, str(res))
     check("page present after create", name in _items(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "custom-page.update", "page": name, "name": renamed},
-    ]})
-    check("apply custom-page.update succeeds", rc == 0, err or out)
+    page_id = _items(app_id).get(name, "")
+    ok, res = _try(["custom-page", "rename", app_id, page_id,
+                    "--section-id", section_id, "--name", renamed])
+    check("custom-page rename succeeds", ok, str(res))
     check("page renamed", renamed in _items(app_id) and name not in _items(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "custom-page.delete", "page": renamed, "confirm": True},
-    ]})
-    check("apply custom-page.delete succeeds", rc == 0, err or out)
+    ok, res = _try(["custom-page", "delete", app_id, page_id,
+                    "--section-id", section_id, "--yes"])
+    check("custom-page delete succeeds", ok, str(res))
     check("page gone after delete", renamed not in _items(app_id))
 
 
+def _make_workflow(app_id: str, name: str) -> str:
+    """Create a scheduled (type 5) workflow and return its process id.
+
+    A worksheet-triggered (type 1) workflow with no trigger bound is
+    excluded from the list by HAP, so it can't be resolved by name. A
+    scheduled workflow lists immediately.
+    """
+    _, org_id = state.ensure_app()
+    res = hap(["workflow", "create", "-c", org_id, "-n", name,
+               "-a", app_id, "--type", "5"], check=False)
+    pid = res.get("id") if isinstance(res, dict) else None
+    if not pid:
+        data = hap(["workflow", "list", app_id], check=False)
+        if isinstance(data, dict):
+            data = data.get("list") or data.get("data") or []
+        pid = next((w.get("id") for w in data if w.get("name") == name), None)
+    return pid or ""
+
+
 def case_workflow(app_id: str, section_id: str) -> None:
-    print("scenario: workflow create/update/delete")
+    print("scenario: workflow create/update/delete (bare commands)")
     name, renamed = "LT-flow", "LT-flow-2"
-    # Use a scheduled (type 5) trigger: a worksheet-triggered (type 1)
-    # workflow with no trigger bound is excluded from the list by HAP, so
-    # it can't be resolved by name. A scheduled workflow lists immediately.
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "workflow.create", "name": name, "trigger_type": 5},
-    ]})
-    check("apply workflow.create succeeds", rc == 0, err or out)
+    pid = _make_workflow(app_id, name)
+    check("workflow create succeeds", bool(pid))
     check("workflow present after create", name in _workflow_names(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "workflow.update", "workflow": name, "name": renamed},
-    ]})
-    check("apply workflow.update succeeds", rc == 0, err or out)
+    ok, res = _try(["workflow", "update", pid, "-n", renamed])
+    check("workflow update succeeds", ok, str(res))
     check("workflow renamed", renamed in _workflow_names(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "workflow.delete", "workflow": renamed, "confirm": True},
-    ]})
-    check("apply workflow.delete succeeds", rc == 0, err or out)
+    ok, res = _try(["workflow", "delete", pid, "-y"])
+    check("workflow delete succeeds", ok, str(res))
     check("workflow gone after delete", renamed not in _workflow_names(app_id))
 
 
@@ -350,35 +371,35 @@ def _node_names(pid: str) -> set[str]:
     return {n.get("name") for n in m.values()}
 
 
+def _node_map(pid: str) -> dict:
+    data = hap(["workflow", "node", "list", pid], check=False)
+    return data.get("flowNodeMap", {}) if isinstance(data, dict) else {}
+
+
 def case_node(app_id: str, section_id: str) -> None:
-    print("scenario: workflow node add/rename/delete")
+    print("scenario: workflow node add/rename/delete (bare commands)")
     name = "LT-nodeflow"
-    existing = _workflow_names(app_id)
     # create a scheduled workflow to host nodes
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "workflow.create", "name": name, "trigger_type": 5},
-    ]})
-    check("apply workflow.create (for nodes) succeeds", rc == 0, err or out)
-    data = hap(["workflow", "list", app_id], check=False)
-    if isinstance(data, dict):
-        data = data.get("list") or data.get("data") or []
-    pid = next((w.get("id") for w in data if w.get("name") == name), None)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "node.add", "workflow": name,
-         "node": {"name": "测试节点", "node_type": 13}},
-    ]})
-    check("apply node.add succeeds", rc == 0, err or out)
+    pid = _make_workflow(app_id, name)
+    check("workflow create (for nodes) succeeds", bool(pid))
+    start_id = next((nid for nid, n in _node_map(pid).items()
+                     if n.get("typeId") == 0), None)
+    check("start node resolved", bool(start_id), str(_node_map(pid)))
+    ok, res = _try(["workflow", "node", "add", pid, "--type", "13",
+                    "-n", "测试节点", "--after", start_id])
+    check("node add succeeds", ok, str(res))
     check("node present after add", "测试节点" in _node_names(pid),
           str(_node_names(pid)))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "node.rename", "workflow": name, "node": "测试节点",
-         "name": "改名节点"},
-        {"type": "node.delete", "workflow": name, "node": "改名节点",
-         "confirm": True},
-    ]})
-    check("apply node.rename+delete succeed", rc == 0, err or out)
+    node_id = next((nid for nid, n in _node_map(pid).items()
+                    if n.get("name") == "测试节点"), "")
+    ok, res = _try(["workflow", "node", "rename", pid, node_id,
+                    "-n", "改名节点"])
+    check("node rename succeeds", ok, str(res))
+    check("node renamed", "改名节点" in _node_names(pid), str(_node_names(pid)))
+    ok, res = _try(["workflow", "node", "delete", pid, node_id, "-y"])
+    check("node delete succeeds", ok, str(res))
     names = _node_names(pid)
-    check("node renamed then deleted",
+    check("node gone after delete",
           "改名节点" not in names and "测试节点" not in names, str(names))
     hap(["workflow", "delete", pid, "--yes"], check=False)
 
@@ -389,29 +410,25 @@ def _sections(app_id: str) -> dict[str, str]:
 
 
 def case_application(app_id: str, section_id: str) -> None:
-    print("scenario: app.update + section add/update/delete")
+    print("scenario: app update + section add/edit/delete (bare commands)")
     name, renamed = "LT-section", "LT-section-2"
     secs = _sections(app_id)
     for n in (name, renamed):
         if n in secs:
             hap(["app", "delete-section", app_id, secs[n], "-y"], check=False)
-    # app.update: set nav color (cosmetic, no restore needed)
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "app.update", "nav_color": "#2296F3"},
-        {"type": "section.add", "name": name},
-    ]})
-    check("apply app.update + section.add succeed", rc == 0, err or out)
+    # app update: set nav color (cosmetic, no restore needed)
+    ok, res = _try(["app", "update", app_id, "--nav-color", "#2296F3"])
+    check("app update succeeds", ok, str(res))
+    ok, res = _try(["app", "add-section", app_id, "-n", name])
+    check("add-section succeeds", ok, str(res))
     check("section present after add", name in _sections(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "section.update", "section": name, "name": renamed},
-    ]})
-    check("apply section.update succeeds", rc == 0, err or out)
+    sec_id = _sections(app_id).get(name, "")
+    ok, res = _try(["app", "edit-section", app_id, sec_id, "-n", renamed])
+    check("edit-section succeeds", ok, str(res))
     check("section renamed", renamed in _sections(app_id)
           and name not in _sections(app_id))
-    rc, out, err = editor_apply({"app": app_id, "ops": [
-        {"type": "section.delete", "section": renamed, "confirm": True},
-    ]})
-    check("apply section.delete succeeds", rc == 0, err or out)
+    ok, res = _try(["app", "delete-section", app_id, sec_id, "-y"])
+    check("delete-section succeeds", ok, str(res))
     check("section gone after delete", renamed not in _sections(app_id))
 
 
@@ -497,6 +514,28 @@ def case_app_logs(app_id: str, section_id: str) -> None:
           f"foreign apps: {sorted(foreign)}")
 
 
+def case_retired_op_rejected(app_id: str, section_id: str) -> None:
+    """`hap app-editor validate` must reject retired ops and point at the
+    bare CLI replacement."""
+    print("scenario: retired edit-spec op rejected by validate")
+    spec = {"app": app_id, "ops": [
+        {"type": "view.update", "worksheet": "x", "view": "y", "name": "z"},
+    ]}
+    with tempfile.NamedTemporaryFile(
+            "w", suffix=".edit.json", delete=False, encoding="utf-8") as fh:
+        json.dump(spec, fh, ensure_ascii=False)
+        path = fh.name
+    try:
+        rc, out, err = editor(["validate", path])
+    finally:
+        Path(path).unlink(missing_ok=True)
+    check("validate exits non-zero for retired op", rc != 0,
+          f"rc={rc} out={out!r}")
+    blob = err + out
+    check("error points at bare command",
+          "hap worksheet view update" in blob, blob.strip())
+
+
 _CASES = {
     "worksheet": case_worksheet,
     "field": case_field,
@@ -509,6 +548,7 @@ _CASES = {
     "workflow": case_workflow,
     "node": case_node,
     "application": case_application,
+    "retired-op": case_retired_op_rejected,
     "app-usage": case_app_usage,
     "app-export": case_app_export,
     "app-logs": case_app_logs,

{hap_cli-0.8.0 → hap_cli-0.8.2}/hap_cli/__init__.py

@@ -1,3 +1,3 @@
 """CLI harness for MingDAO HAP (hap-cli)."""
 
-__version__ = "0.8.0"
+__version__ = "0.8.2"

{hap_cli-0.8.0 → hap_cli-0.8.2}/hap_cli/commands/app_cmd.py

@@ -154,7 +154,7 @@ def app_unselect(ctx):
 @click.option(
     "--configuration", "configuratiuon",
     default="",
-    help="JSON link-configuration blob (upstream field name is 'configuratiuon' — sic)",
+    help="JSON link-configuration blob",
 )
 @click.option(
     "--pc-display/--no-pc-display", "pc_display", default=None,
@@ -224,6 +224,7 @@ def app_create(
 @click.argument("app_id")
 @click.option("--name", "-n", default="", help="New name")
 @click.option("--desc", "-d", default="", help="New description")
+@click.option("--icon", default="", help="Icon name, e.g. 0_lego")
 @click.option("--icon-color", default="", help="Icon color hex")
 @click.option("--nav-color", default="", help="Navigation bar color hex")
 @click.option(
@@ -238,7 +239,7 @@ def app_create(
     help="Show-icon flag (3 bits, e.g. 011). Defaults by nav style.",
 )
 @pass_context
-def app_update(ctx, app_id, name, desc, icon_color, nav_color,
+def app_update(ctx, app_id, name, desc, icon, icon_color, nav_color,
                pc_nav_style, display_icon):
     """Update application information (incl. PC navigation style)."""
     try:
@@ -251,7 +252,7 @@ def app_update(ctx, app_id, name, desc, icon_color, nav_color,
             # pcNavList[*].defaultDisplayIcon).
             di = "100" if nav == 3 else "011"
         data = app_mod.update_app(
-            session, app_id, name=name, description=desc,
+            session, app_id, name=name, description=desc, icon=icon,
             icon_color=icon_color, nav_color=nav_color,
             pc_nav_style=nav, display_icon=di,
         )
@@ -318,13 +319,43 @@ def app_delete(ctx, app_id, org_id, yes):
 @app.command("add-section")
 @click.argument("app_id")
 @click.option("--name", "-n", default="", help="Section name")
+@click.option(
+    "--sections-json", default="",
+    help='Several sections at once, as a JSON array, e.g. '
+         '\'[{"name": "Ops", "icon": "folder"}]\' '
+         '(alternative to --name)',
+)
+@click.option(
+    "--parent-id", default="",
+    help="Parent section ID; omit to create at the top level",
+)
 @pass_context
-def app_add_section(ctx, app_id, name):
-    """Add a section/group to an application."""
+def app_add_section(ctx, app_id, name, sections_json, parent_id):
+    """Add one or more sections/groups to an application."""
     try:
+        import json as _json
+        if name and sections_json:
+            raise click.UsageError(
+                "Use either --name or --sections-json, not both.")
         session = ctx.get_session()
-        data = app_mod.add_section(session, app_id, name)
-        ctx.output(data, lambda d: click.echo(f"Section added: {d}"))
+        if sections_json:
+            try:
+                parsed = _json.loads(sections_json)
+            except ValueError as e:
+                raise click.UsageError(f"--sections-json is not valid JSON: {e}")
+            try:
+                sections = app_mod.v3_sections_to_add_section_calls(parsed)
+            except ValueError as e:
+                raise click.UsageError(f"--sections-json: {e}")
+            data = app_mod.add_sections_batch(
+                session, app_id, sections, parent_id=parent_id,
+            )
+            ctx.output(data, lambda d: click.echo(f"Sections added: {d}"))
+        else:
+            data = app_mod.add_section(
+                session, app_id, name, parent_id=parent_id,
+            )
+            ctx.output(data, lambda d: click.echo(f"Section added: {d}"))
     except Exception as e:
         ctx.handle_error(e)
 
@@ -382,19 +413,27 @@ def app_backup(ctx, app_id, org_id, no_data):
 @app.command("restore")
 @click.argument("app_id")
 @org_id_option()
-@click.option("--backup-id", "-b", required=True, help="Backup ID")
-@click.option("--file-url", required=True, help="Backup file URL")
-@click.option("--file-name", required=True, help="Backup file name")
+@click.option("--backup-id", "-b", default="", help="Restore from an existing backup (its ID)")
+@click.option("--file-url", default="", help="Restore from an uploaded backup file (its URL)")
+@click.option("--file-name", default="", help="File name to show for an uploaded backup file")
 @click.option("--no-data", is_flag=True, help="Restore without data")
 @click.option("--as-new", is_flag=True, help="Restore as a new app")
 @pass_context
 def app_restore(ctx, app_id, org_id, backup_id, file_url, file_name, no_data, as_new):
-    """Restore an application from backup."""
+    """Restore an application, either from an existing backup or an uploaded file.
+
+    Provide exactly one source: --backup-id (an existing backup) or
+    --file-url (an uploaded backup file).
+    """
     try:
+        if bool(backup_id) == bool(file_url):
+            raise click.UsageError(
+                "Provide exactly one of --backup-id or --file-url."
+            )
         session = ctx.get_session()
         data = app_mod.restore_app(
-            session, app_id, require_api_project_id(session, org_id), backup_id,
-            file_url, file_name,
+            session, app_id, require_api_project_id(session, org_id),
+            backup_id=backup_id, file_url=file_url, file_name=file_name,
             contain_data=not no_data, is_restore_new=as_new,
         )
         ctx.output(data, lambda d: click.echo(f"Restore started: {d}"))

{hap_cli-0.8.0 → hap_cli-0.8.2}/hap_cli/commands/app_editor_cmd.py

@@ -2,8 +2,12 @@
 
 Thin Click layer over the editor engine in ``hap_cli.core.editor``:
 edit-spec validation, live inspection, dry-run planning, and applying
-single-element changes (worksheet / field / view / role / custom-action /
-workflow / custom-page / component / chatbot / node / app / section).
+the edits whose safe orchestration lives in the engine — worksheet
+fields (full-control-set write-back), custom-page components
+(layout read-modify-write), and custom-action create/update (high-level
+spec translation). Every other element edit is a single API call served
+by a plain ``hap`` command; retired op types are rejected with the
+replacement command (see ``editspec.RETIRED_OPS``).
 
 The edit-spec schemas are documented and shipped with the
 ``hap-cli-app-editor`` skill; this command resolves them at runtime.