hap-cli 0.8.11__tar.gz → 0.8.13__tar.gz

{hap_cli-0.8.11 → hap_cli-0.8.13}/PKG-INFO

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

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/__init__.py

@@ -1,3 +1,3 @@
 """CLI harness for Mingdao HAP (hap-cli)."""
 
-__version__ = "0.8.11"
+__version__ = "0.8.13"

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/commands/post_cmd.py

@@ -425,8 +425,8 @@ def _normalize_scope(scope: str) -> str:
         "fav=your favorites, group=posts in a group (requires --group-id)."
     ),
 )
-@click.option("--account-id", default="", help="Member id (required when --scope=user)")
-@click.option("--group-id", default="", help="Group id (required when --scope=group)")
+@click.option("--account-id", default="", help="Show only this member's posts")
+@click.option("--group-id", default="", help="Show only this group's posts")
 @click.option("-k", "--keywords", default="", help="Keyword filter")
 @click.option("--start-date", default="", help="Only posts on or after this date (YYYY-MM-DD)")
 @click.option("--end-date", default="", help="Only posts on or before this date (YYYY-MM-DD)")

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/commands/role_cmd.py

@@ -208,6 +208,52 @@ def role_set_permissions(ctx, app_id, role_id, permissions, permission_way):
         ctx.handle_error(e)
 
 
+@role.command("set-chatbots")
+@click.argument("app_id")
+@click.argument("role_id")
+@click.option("--enable-all", is_flag=True,
+              help="Grant this role access to every AI assistant in the app.")
+@click.option("--disable-all", is_flag=True,
+              help="Remove this role's access to every AI assistant in the app.")
+@click.option("--chatbots-json", default="",
+              help='Per-assistant access as a JSON array, e.g. '
+                   '[{"id":"<assistant-id>","enable":true}].')
+@pass_context
+def role_set_chatbots(ctx, app_id, role_id, enable_all, disable_all, chatbots_json):
+    """Set which AI assistants a role can access.
+
+    A newly created fine-grained role has no AI-assistant access until it
+    is granted here. Provide exactly one of --enable-all, --disable-all,
+    or --chatbots-json.
+    """
+    try:
+        chosen = sum(bool(x) for x in (enable_all, disable_all, chatbots_json))
+        if chosen != 1:
+            raise click.UsageError(
+                "Provide exactly one of --enable-all, --disable-all, "
+                "or --chatbots-json."
+            )
+        session = ctx.get_session()
+        enables = None
+        default = None
+        if enable_all:
+            default = True
+        elif disable_all:
+            default = False
+        else:
+            entries = json.loads(chatbots_json)
+            enables = {
+                e["id"]: bool(e.get("enable", True))
+                for e in entries if e.get("id")
+            }
+        data = role_mod.set_role_chatbots(
+            session, app_id, role_id, enables=enables, default=default,
+        )
+        ctx.output(data, lambda d: click.echo("AI assistant access updated."))
+    except Exception as e:
+        ctx.handle_error(e)
+
+
 @role.command("rename")
 @click.argument("app_id")
 @click.argument("role_id")

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/app_creator/design/design.schema.json

@@ -3485,6 +3485,28 @@
           },
           "description": "permission_scope=0 时的自定义页面权限明细（页面按逻辑名）。"
         },
+        "chatbot_permissions": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": [
+              "chatbot"
+            ],
+            "additionalProperties": false,
+            "properties": {
+              "chatbot": {
+                "type": "string",
+                "description": "AI 助手逻辑名 -> id。"
+              },
+              "enable": {
+                "type": "boolean",
+                "default": true,
+                "description": "是否可访问该 AI 助手。"
+              }
+            }
+          },
+          "description": "可访问的 AI 助手（chatbot）明细，按 chatbot 逻辑名引用。省略该键 = 该角色可访问应用内全部 AI 助手（默认开放）。一旦提供本数组，则只有列出且 enable=true 的助手可访问，其余助手一律不可访问。"
+        },
         "members": {
           "type": "object",
           "additionalProperties": false,

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/app_creator/selftest.py

@@ -67,6 +67,45 @@ def test_store() -> None:
         pass
 
 
+def test_role_chatbot_enables() -> None:
+    from hap_cli.core.app_creator.store import Store
+    from hap_cli.core.app_creator.steps import _role_chatbot_enables
+
+    d = Path(tempfile.mkdtemp()) / "appCB"
+    s = Store(d)
+    s.put_app("appCB", "Demo", "org1", [{"id": "sec1", "name": "分析"}])
+    # No chatbots in the app -> nothing to grant.
+    assert _role_chatbot_enables(s, {"name": "r"}) == {}
+
+    s.put_entity("chatbot", "cb1", "订单助手", {"name": "订单助手"})
+    s.put_entity("chatbot", "cb2", "客服助手", {"name": "客服助手"})
+    # chatbot_permissions omitted -> every assistant is granted (the fix).
+    assert _role_chatbot_enables(s, {"name": "r"}) == {"cb1": True, "cb2": True}
+    # Provided -> whitelist: only listed enable:true granted, the rest off.
+    role = {"name": "r",
+            "chatbot_permissions": [{"chatbot": "订单助手", "enable": True}]}
+    assert _role_chatbot_enables(s, role) == {"cb1": True, "cb2": False}
+    # enable defaults true when omitted; explicit false revokes a listed one.
+    role2 = {"name": "r", "chatbot_permissions": [
+        {"chatbot": "订单助手", "enable": False},
+        {"chatbot": "客服助手"},
+    ]}
+    assert _role_chatbot_enables(s, role2) == {"cb1": False, "cb2": True}
+
+
+def test_role_chatbot_permissions_schema() -> None:
+    design = {
+        "app": {"name": "x"},
+        "worksheets": [{"name": "t", "fields": [
+            {"type": "Text", "name": "标题", "is_title": True}]}],
+        "chatbots": [{"name": "助手"}],
+        "roles": [{"name": "r", "permission_scope": "0",
+                   "chatbot_permissions": [{"chatbot": "助手", "enable": True}]}],
+    }
+    errs = _vd(design)
+    assert not any("chatbot_permissions" in e for e in errs), errs
+
+
 def test_schema() -> None:
     from hap_cli.core.app_creator import schema
 

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/app_creator/steps.py

@@ -962,6 +962,33 @@ def _build_ws_perm(store: Store, wp: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _role_chatbot_enables(store: Store, role: dict[str, Any]) -> dict[str, bool]:
+    """Map every app chatbot id -> whether this role may access it.
+
+    The fine-grained role-create endpoint can't grant AI-assistant
+    access, so the role handler patches it in afterwards (via
+    ``app role set-chatbots`` -> EditAppRole). Default: every assistant in
+    the app is accessible to the role. A role narrows this with
+    ``chatbot_permissions`` (a list of ``{chatbot, enable}``); when that
+    key is present only the listed assistants with ``enable: true`` are
+    granted and all other assistants are revoked.
+
+    Returns an empty mapping when the app has no chatbots (nothing to do).
+    """
+    ids = [c["id"] for c in store.list("chatbot") if c.get("id")]
+    if not ids:
+        return {}
+    cp = role.get("chatbot_permissions")
+    if cp is None:
+        return {cid: True for cid in ids}
+    wanted: dict[str, bool] = {}
+    for item in cp:
+        wanted[store.resolve("chatbot", item["chatbot"])] = bool(
+            item.get("enable", True)
+        )
+    return {cid: bool(wanted.get(cid, False)) for cid in ids}
+
+
 @handler("role")
 def _h_role(ctx: ExecCtx, step: Step) -> StepOutcome:
     store = _require_store(ctx)
@@ -1021,6 +1048,20 @@ def _h_role(ctx: ExecCtx, step: Step) -> StepOutcome:
             hap.run(m_argv)
             commands.append(m_argv)
 
+    # Grant AI-assistant (chatbot) access. The fine-grained role-create
+    # endpoint has no field for it, so every role would otherwise be unable
+    # to reach the app's assistants. Chatbots are built before roles, so
+    # they already exist in the store here.
+    enables = _role_chatbot_enables(store, role)
+    if role_id and enables:
+        cb_argv = ["app", "role", "set-chatbots", ctx.store.app_id, role_id,
+                   "--chatbots-json",
+                   json.dumps([{"id": cid, "enable": en}
+                               for cid, en in enables.items()],
+                              ensure_ascii=False)]
+        hap.run(cb_argv)
+        commands.append(cb_argv)
+
     return StepOutcome(
         created_id=role_id, summary=f"role {name!r} scope={scope}",
         commands=commands, capture_files=[f"role_{role_id}.json", "roles.json"],

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/chat.py

@@ -107,11 +107,35 @@ def _paginate_chat_list_for_cli(
     return sessions[start:end]
 
 
+# chatmq session `type` (pd-openweb src/pages/chat/utils/constant.js
+# SESSIONTYPE_*) → the value a caller passes next to reach that session's
+# detail. For inbox buckets this is the `chat messages --category` key
+# (note: type 9 worksheet → `app`, type 7 knowledge → `kc`, matching
+# INBOX_CATEGORY_TYPES). For direct chats it is `user` / `group`, a hint
+# that the detail fetch uses `--with-user` / `--group-id` with this
+# session's `value` instead of `--category`.
+CHAT_SESSION_TYPE_TO_CATEGORY: dict[int, str] = {
+    1: "user",
+    2: "group",
+    3: "system",
+    4: "post",
+    5: "calendar",
+    6: "task",
+    7: "kc",
+    8: "hr",
+    9: "app",
+    10: "workflow",
+}
+
+
 def _simplify_chat_session(item: Any) -> Any:
     """Rename a couple of cryptic chatmq keys to CLI-friendly names.
 
     - ``count`` → ``unread`` (unread message count for the session)
     - ``pid``   → ``orgId``  (the network/organization id this session belongs to)
+    - ``category`` is *added* (see ``CHAT_SESSION_TYPE_TO_CATEGORY``) so a
+      caller can chain from a session to its message detail without
+      re-deriving the mapping.
 
     Everything else is passed through unchanged so callers that depend
     on the wider session shape (msg, top_info, isPush, etc.) keep
@@ -124,6 +148,9 @@ def _simplify_chat_session(item: Any) -> Any:
         out["unread"] = out.pop("count")
     if "pid" in out:
         out["orgId"] = out.pop("pid")
+    category = CHAT_SESSION_TYPE_TO_CATEGORY.get(out.get("type"))
+    if category:
+        out["category"] = category
     return out
 
 
@@ -580,9 +607,12 @@ INBOX_CATEGORY_TYPES: dict[str, str] = {
 
 # Discussion `inboxType` values that encode the source reference in
 # `sourceId` differently. Kept central so adding a new discussion type is a
-# one-line change. Source: pd-openweb MSGTYPES enum.
-_DISCUSSION_WORKSHEET_TYPES = {41, 42}  # WorkSheetRowReply / WorkSheetRowComment
-_DISCUSSION_CALENDAR_TYPES = {26, 28}   # CalendarMentioned / CalendarComment (AttendanceReply)
+# one-line change. Source: pd-openweb MSGTYPES enum
+# (src/pages/chat/components/Inbox/constants.js).
+# Worksheet-ROW discussions span four subtypes — system(40)/mentioned(41)/
+# reply(42)/comment(43) — all carrying sourceId=`<worksheetId>|<rowId>`.
+_DISCUSSION_WORKSHEET_TYPES = {40, 41, 42, 43}
+_DISCUSSION_CALENDAR_TYPES = {26, 28}   # CalendarMentioned / CalendarReply
 _DISCUSSION_TASK_TYPES = {12}           # TaskReply
 
 
@@ -647,10 +677,28 @@ def _normalize_attachment(att: Any) -> Optional[dict[str, Any]]:
     return out
 
 
-def _split_discussion_source(inbox_type: int, source_id: str) -> dict[str, Any]:
-    """Resolve `discussion.sourceId` into CLI-native ID fields per type.
+def _is_usable_id(value: str) -> bool:
+    """An id segment is usable unless it is empty or a literal undefined/null.
+
+    Mirrors ``buildSourceLink`` (Inbox/util.js), which discards an
+    ``extendsId`` containing ``undefined`` / ``null`` rather than building a
+    broken link from it.
+    """
+    return bool(value) and value not in ("undefined", "null")
+
 
-    - Worksheet-row (41/42): `<worksheetId>|<rowId>`.
+def _split_discussion_source(
+    inbox_type: int, source_id: str, extends_id: str = ""
+) -> dict[str, Any]:
+    """Resolve `discussion.sourceId` (+ `extendsId`) into CLI-native ID fields.
+
+    - Worksheet-row (40/41/42/43): `sourceId` = `<worksheetId>|<rowId>` and
+      `extendsId` = `<appId>|<viewId>` (pd-openweb
+      src/api/discussion.js, commentListItem.jsx:176, Inbox/util.js
+      buildSourceLink). The item-level `appId` on these notifications is the
+      stale notification-feed app (often deleted), so the *record's* real app
+      must come from `extendsId` — surfacing it here lets the returned dict
+      override that stale value at the call site.
     - Calendar (26/28): `<calendarId>|` (second half always empty).
     - Task (12): no `|`, whole string is the task id.
     - Other: keep the raw `sourceId` so future enums don't silently lose info.
@@ -658,11 +706,16 @@ def _split_discussion_source(inbox_type: int, source_id: str) -> dict[str, Any]:
     source_id = source_id or ""
     if inbox_type in _DISCUSSION_WORKSHEET_TYPES:
         worksheet_id, _, row_id = source_id.partition("|")
+        app_id, _, view_id = (extends_id or "").partition("|")
         result: dict[str, Any] = {}
+        if _is_usable_id(app_id):
+            result["appId"] = app_id
         if worksheet_id:
             result["worksheetId"] = worksheet_id
         if row_id:
             result["rowId"] = row_id
+        if _is_usable_id(view_id):
+            result["viewId"] = view_id
         return result
     if inbox_type in _DISCUSSION_CALENDAR_TYPES:
         calendar_id, _, _rest = source_id.partition("|")
@@ -776,6 +829,54 @@ def _extract_hr_ids(text: Any) -> tuple[Optional[str], Optional[str]]:
     return (aid_m.group(1) if aid_m else None), org_m.group(1)
 
 
+# Worksheet-row links embedded in `Message.content` HTML for notifications
+# that carry no `discussion` object — workflow notifications (CC/抄送,
+# fill, approval) and worksheet system messages ("被工作流添加为参与者").
+# Three shapes occur (pd-openweb src/pages/workflow/socket/index.js:124 and
+# Inbox/util.js buildSourceLink); an id segment runs until the next `/`, `?`,
+# quote, or angle bracket. Ordered most-specific first.
+_APP_ROW_RE = re.compile(
+    r"/app/([^/?\"'<>\s]+)/([^/?\"'<>\s]+)/([^/?\"'<>\s]+)/row/([^/?\"'<>\s]+)"
+)
+_MOBILE_RECORD_RE = re.compile(
+    r"/mobile/record/([^/?\"'<>\s]+)/([^/?\"'<>\s]+)/([^/?\"'<>\s]+)/([^/?\"'<>\s]+)"
+)
+_WS_ROW_RE = re.compile(r"/worksheet/([^/?\"'<>\s]+)/row/([^/?\"'<>\s]+)")
+
+
+def _extract_record_ref(text: Any) -> dict[str, Any]:
+    """Pull the first worksheet-row reference out of notification HTML.
+
+    Returns any of ``appId`` / ``worksheetId`` / ``viewId`` / ``rowId`` that
+    the embedded record link encodes, so Message-carrier notifications
+    (which have no structured ``discussion`` block) still surface a record
+    the user can jump to. Empty dict when no record link is present.
+    """
+    if not text:
+        return {}
+    s = str(text)
+    m = _APP_ROW_RE.search(s)
+    if m:
+        return {
+            "appId": m.group(1),
+            "worksheetId": m.group(2),
+            "viewId": m.group(3),
+            "rowId": m.group(4),
+        }
+    m = _MOBILE_RECORD_RE.search(s)
+    if m:
+        return {
+            "appId": m.group(1),
+            "worksheetId": m.group(2),
+            "viewId": m.group(3),
+            "rowId": m.group(4),
+        }
+    m = _WS_ROW_RE.search(s)
+    if m:
+        return {"worksheetId": m.group(1), "rowId": m.group(2)}
+    return {}
+
+
 def _simplify_scope(scope: Any) -> Optional[dict[str, Any]]:
     """Reduce ``Post.scope`` to ``{"shareGroups": [{id, name}]}``.
 
@@ -1065,8 +1166,17 @@ def _simplify_inbox_item(item: dict[str, Any]) -> dict[str, Any]:
         message, comment_simplified = _simplify_comment_payload(discussion, inbox_type)
         if comment_simplified:
             simplified["comment"] = comment_simplified
-        # Split the discussion.sourceId into CLI-native id fields.
-        simplified.update(_split_discussion_source(inbox_type, discussion.get("sourceId") or ""))
+        # Split the discussion.sourceId (+ extendsId) into CLI-native id
+        # fields. For worksheet-row discussions this yields the record's real
+        # appId, which intentionally overrides the stale item-level appId set
+        # above.
+        simplified.update(
+            _split_discussion_source(
+                inbox_type,
+                discussion.get("sourceId") or "",
+                discussion.get("extendsId") or "",
+            )
+        )
     elif isinstance(message_obj, dict):
         # System-message carrier across all categories (system / task /
         # calendar / kc / hr / app / workflow): the HAP server pre-renders
@@ -1092,6 +1202,16 @@ def _simplify_inbox_item(item: dict[str, Any]) -> dict[str, Any]:
             simplified["accountId"] = hr_account_id
         if hr_org_id:
             simplified["orgId"] = hr_org_id
+        # Workflow (CC/抄送, fill, approval) and worksheet system messages
+        # embed the triggering record as a row link in the HTML — surface
+        # appId/worksheetId/viewId/rowId so the record is directly reachable.
+        # `app.id` (when present) is authoritative for the app, so don't let
+        # the link's appId duplicate it; never clobber ids already set.
+        record_ref = _extract_record_ref(raw_content)
+        if "app" in simplified:
+            record_ref.pop("appId", None)
+        for key, value in record_ref.items():
+            simplified.setdefault(key, value)
 
     # `message` is always present — user-facing primary text. Empty-string OK.
     simplified["message"] = message

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/flow_node.py

@@ -5,11 +5,14 @@ data processing nodes (create/update/delete/search records),
 code test, webhook test, AIGC test, code templates, and JSON-to-controls.
 """
 
+import logging
 from typing import Any, Optional
 
 from hap_cli.core.session import Session
 from hap_cli.utils.parameter_mapping import parameter_mapping
 
+logger = logging.getLogger("hap_cli.workflow")
+
 
 # ── Node Type Constants ──────────────────────────────────────────────────
 
@@ -391,6 +394,24 @@ def save_node(
     if select_node_id:
         data["selectNodeId"] = select_node_id
     data.update(config)
+    # Branch items (flowNodeType 2) have an asymmetric read/write key for
+    # their filter: getNodeDetail returns it as ``conditions`` (see
+    # pd-openweb Branch/index.jsx, which reads ``result.conditions``), but
+    # saveNode only persists it under ``operateCondition`` (the same file
+    # sends ``saveNode({ operateCondition: data })``). The value shape is
+    # identical. Saving with the read-side ``conditions`` key is silently
+    # ignored by the server — the save still reports success but the
+    # condition is dropped. Accept the read key so copying a node's
+    # read structure straight back round-trips correctly.
+    if flow_node_type == 2 and "conditions" in data:
+        if "operateCondition" not in data:
+            data["operateCondition"] = data["conditions"]
+            logger.info(
+                "save_node: branch item %s — mapped read-side key "
+                "'conditions' to write-side 'operateCondition'", node_id)
+        # ``conditions`` is not a saveNode key; drop it so it doesn't ride
+        # along as dead weight.
+        data.pop("conditions", None)
     return session.workflow_call("flowNode/saveNode", data)
 
 

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/post.py

@@ -72,7 +72,31 @@ def get_post_list(
     For ``lType == "project"`` (org-wide feed), ``range`` follows the
     frontend convention when not overridden: no projectId → 0
     (cross-network), concrete projectId → 2.
+
+    Effective-scope derivation (mirrors ``postActions.loadPosts``): the
+    server keys off ``lType`` to decide which feed to read, and silently
+    ignores ``aId`` / ``gID`` when they don't match the declared scope.
+    The frontend therefore derives the effective ``lType`` from the
+    presence of the ids — a group id forces ``group``, an account id
+    forces ``user`` — rather than trusting the nominal list type. We do
+    the same so that e.g. ``--account-id`` filters the author feed even
+    when the caller left the scope at its org-wide default.
+
+    ``myself`` is handled specially: the bare ``lType=myself`` scope
+    lists the caller's posts but the server drops keyword / date filters
+    on it. The product's "我的"(My) tab actually routes through
+    ``lType=user`` with the caller's own accountId, so we resolve
+    ``myself`` to that shape when the session knows the caller's id
+    (falling back to the raw scope otherwise).
     """
+    if list_type == "myself" and not account_id and not group_id and session.account_id:
+        account_id = session.account_id
+
+    if group_id:
+        list_type = "group"
+    elif account_id:
+        list_type = "user"
+
     data: dict[str, Any] = {
         "fType": source_type or "feed",
         "lType": list_type,

{hap_cli-0.8.11 → hap_cli-0.8.13}/hap_cli/core/role.py

@@ -238,6 +238,54 @@ def set_role_permissions(
     )
 
 
+def set_role_chatbots(
+    session: Session,
+    app_id: str,
+    role_id: str,
+    enables: Optional[dict[str, bool]] = None,
+    default: Optional[bool] = None,
+    project_id: str = "",
+) -> dict[str, Any]:
+    """Grant or revoke a role's access to the app's AI assistants.
+
+    The fine-grained role-create endpoint (V3 ``/v3/app/roles``) carries
+    no field for AI-assistant access, so a freshly created role can never
+    reach the app's assistants. The legacy role model *does* carry a
+    ``chatbots`` array (each entry ``{id, name, checked, navigateHide,
+    sortIndex, iconUrl}``); the UI saves it through GetRoleDetail ->
+    EditAppRole as part of the full ``appRoleModel``.
+
+    Evidence: pd-openweb ``src/pages/Role/component/RoleSet/SheetTable.jsx``
+    (the AI-assistant checkbox toggles ``checked``) and ``SettingForm.jsx``
+    (chatbots are saved alongside sheets/pages in the role model).
+
+    ``enables`` maps a chatbot id to its desired ``checked`` value.
+    ``default`` (when not None) is applied to every chatbot in the model
+    that is *not* named in ``enables`` — pass ``default=True`` to grant
+    all, ``default=False`` to revoke all. Chatbot ids in ``enables`` that
+    do not exist in the role model are ignored.
+    """
+    enables = enables or {}
+    detail = get_role_detail(session, app_id, role_id)
+    model = dict(detail) if isinstance(detail, dict) else {}
+    chatbots = model.get("chatbots") or []
+    for cb in chatbots:
+        if not isinstance(cb, dict):
+            continue
+        cid = cb.get("id")
+        if cid in enables:
+            cb["checked"] = bool(enables[cid])
+        elif default is not None:
+            cb["checked"] = bool(default)
+    model["chatbots"] = chatbots
+    data: dict[str, Any] = {
+        "appId": app_id, "roleId": role_id, "appRoleModel": model,
+    }
+    if project_id:
+        data["projectId"] = project_id
+    return session.api_call("AppManagement", "EditAppRole", data)
+
+
 def apply_role(
     session: Session, app_id: str, remark: str = "",
 ) -> dict[str, Any]: