hap-cli 0.8.27__tar.gz → 0.8.28__tar.gz

{hap_cli-0.8.27 → hap_cli-0.8.28}/PKG-INFO

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

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/__init__.py

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

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/commands/chat_cmd.py

@@ -274,8 +274,11 @@ def chat_send_to_one(ctx, to, message, files, dry_run):
     \b
       hap chat send-to-one -t <accountId> -m "spec attached" -f ./spec.pdf
 
-    Text and each file arrive as separate messages, in that order. You
-    cannot message yourself — your own account is skipped.
+    Text and each file arrive as separate messages, in that order.
+
+    To message yourself, send to the file-transfer assistant with
+    -t file-transfer. Your own account id is not a valid target and is
+    skipped.
     """
     if not to:
         ctx.handle_error(click.UsageError(
@@ -302,9 +305,20 @@ def chat_send_to_one(ctx, to, message, files, dry_run):
         return
     try:
         session = ctx.get_session()
+        # The file-transfer assistant is a conversation id, not an account
+        # id, so the account-addressed endpoint drops it silently. It goes
+        # over the socket path the chat panel uses instead.
+        socket_targets = [t for t in to if t == chat_mod.FILE_TRANSFER_ID]
+        account_targets = [t for t in to if t != chat_mod.FILE_TRANSFER_ID]
         if not sources:
-            data = chat_mod.send_message(session, list(to), message)
-            ctx.output(data, lambda d: click.echo("Message sent."))
+            results = {}
+            if account_targets:
+                results["accounts"] = chat_mod.send_message(
+                    session, account_targets, message)
+            for target in socket_targets:
+                results[target] = chat_mod.send_user_message(
+                    session, target, message)
+            ctx.output(results, lambda d: click.echo("Message sent."))
             return
         descriptors = chat_mod.upload_chat_files(session, sources)
         acks = chat_mod.send_files(session, list(to), descriptors, message)
@@ -430,3 +444,65 @@ def chat_card_detail(ctx, task, post, calendar, kcfile, worksheet, worksheetrow)
     except Exception as e:
         ctx.handle_error(e)
 
+
+
+@chat.command("recall")
+@click.argument("message_id")
+@click.option("--group-id", "group_id", default="", help="Group id the message is in")
+@click.option("--with-user", "with_user", default="",
+              help="Peer accountId for a 1-on-1 message")
+@click.option("--time", "msg_time", default="",
+              help="Send time of the message. Looked up from the conversation "
+                   "when omitted.")
+@click.option("--as-admin", is_flag=True,
+              help="Recall as a group admin. Admins may recall another "
+                   "member's message; ordinary recall only covers your own.")
+@click.option("--dry-run", is_flag=True,
+              help="Show which message would be recalled, without recalling it.")
+@pass_context
+def chat_recall(ctx, message_id, group_id, with_user, msg_time, as_admin, dry_run):
+    """Recall a message you sent.
+
+    You can recall your own message within 5 minutes of sending it; a group
+    admin can recall another member's message with no time limit. A recall
+    cannot be undone.
+    """
+    if bool(group_id) == bool(with_user):
+        raise click.UsageError("Pass exactly one of --group-id or --with-user.")
+    try:
+        session = ctx.get_session()
+        found = None
+        if not msg_time:
+            # The recall payload carries the message's send time; look it
+            # up so the caller only needs the message id.
+            history = (
+                chat_mod.get_group_messages(session, group_id, num=50)
+                if group_id else
+                chat_mod.get_user_messages(session, with_user, num=50)
+            ) or []
+            for m in history:
+                if str(m.get("id")) == str(message_id):
+                    found = m
+                    msg_time = m.get("time", "")
+                    break
+        if dry_run:
+            ctx.output(
+                {"messageId": message_id,
+                 "groupId": group_id, "withUser": with_user,
+                 "time": msg_time,
+                 "preview": ((found or {}).get("msg") or {}).get("con"),
+                 "recalled": False},
+                lambda d: click.echo(
+                    f"Would recall {d['messageId']}"
+                    + (f" ({d['preview']!r})" if d.get("preview") else "")),
+            )
+            return
+        admin_id = session.account_id if as_admin else ""
+        data = chat_mod.withdraw_message(
+            session, message_id,
+            group_id=group_id, to_user=with_user,
+            time=msg_time, admin_account_id=admin_id,
+        )
+        ctx.output(data, lambda d: click.echo("Message recalled."))
+    except Exception as e:
+        ctx.handle_error(e)

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/commands/post_cmd.py

@@ -644,25 +644,74 @@ def post_get(ctx, post_id):
     help="Post type: 0=text, 3=link, 5=vote, 7=file",
 )
 @click.option(
-    "--share-group",
+    "--to-group",
     "share_group_ids",
     multiple=True,
-    help="Also share to this group id (repeatable)",
+    help="Audience: members of this group can see the post (repeatable). "
+         "Naming a group does not also publish to the organization.",
 )
 @click.option(
-    "--share-org",
+    "--to-org",
     "share_org_ids",
     multiple=True,
-    help=(
-        "Share to this organization id (repeatable). If omitted, the post "
-        "goes only to --org-id."
-    ),
+    help="Audience: everyone in this organization can see the post "
+         "(repeatable). This is the company-wide feed.",
 )
+@click.option("--share-group", "legacy_group_ids", multiple=True, hidden=True)
+@click.option("--share-org", "legacy_org_ids", multiple=True, hidden=True)
+@click.option("--card-to-group", "card_group_ids", multiple=True,
+              help="After publishing, also send a card linking to the post "
+                   "into this group chat (repeatable). This is a chat "
+                   "message and does not change who can see the post.")
+@click.option("--dry-run", is_flag=True,
+              help="Show the audience and what would be sent, without publishing.")
 @pass_context
-def post_create(ctx, org_id, message, post_type, share_group_ids, share_org_ids):
-    """Create a new post in the given organization."""
+def post_create(ctx, org_id, message, post_type, share_group_ids, share_org_ids,
+                legacy_group_ids, legacy_org_ids, card_group_ids, dry_run):
+    """Create a new post in the given organization.
+
+    Audience is set with --to-group / --to-org and defaults to everyone in
+    --org-id when neither is given. Who can see a post, and sending a card
+    about it to a group chat, are covered in `hap guide post`.
+    """
     try:
+        share_group_ids = tuple(share_group_ids) + tuple(legacy_group_ids)
+        share_org_ids = tuple(share_org_ids) + tuple(legacy_org_ids)
+        if dry_run:
+            audience = (
+                [f"group:{g}" for g in share_group_ids]
+                + [f"org:{o}" for o in share_org_ids]
+            ) or [f"org:{org_id or '<current>'} (everyone, default)"]
+            ctx.output(
+                {"audience": audience, "cardToGroups": list(card_group_ids),
+                 "message": message, "published": False},
+                lambda d: click.echo(
+                    "Would publish to: " + ", ".join(d["audience"])
+                    + (f"; card to groups: {', '.join(d['cardToGroups'])}"
+                       if d["cardToGroups"] else "")),
+            )
+            return
         session = ctx.get_session()
+        # Only a group with the feed turned on can be a post audience. The
+        # server rejects the rest with "选择了没有加入的群组" (you picked a
+        # group you have not joined), which is misleading when you are in
+        # the group — it is a plain chat group with no feed. Check first so
+        # the message names the real reason.
+        if share_group_ids:
+            from hap_cli.core import group as group_mod
+            no_feed = []
+            for gid in share_group_ids:
+                info = group_mod.get_group_info(session, gid) or {}
+                if isinstance(info.get("data"), dict):
+                    info = info["data"]
+                if not info.get("isPost"):
+                    no_feed.append(info.get("name") or gid)
+            if no_feed:
+                raise click.ClickException(
+                    "These groups cannot receive a post because they are chat "
+                    "groups with no feed enabled: " + ", ".join(no_feed)
+                    + ". Pick a group whose feed is on, or send a card to the "
+                      "chat instead with --card-to-group.")
         pid = require_api_project_id(session, org_id)
         raw = post_mod.add_post(
             session,
@@ -674,10 +723,21 @@ def post_create(ctx, org_id, message, post_type, share_group_ids, share_org_ids)
         )
         post_obj = raw.get("post") if isinstance(raw, dict) else None
         summary = _simplify_post(post_obj) if post_obj else {"raw": raw}
+        if card_group_ids and summary.get("id"):
+            from hap_cli.core import chat as chat_mod
+            sent = []
+            for gid in card_group_ids:
+                chat_mod.send_group_post_card(
+                    session, gid, summary["id"], message,
+                    post_type=post_type)
+                sent.append(gid)
+            summary["cardSentToGroups"] = sent
         def _render(d):
             click.echo(f"Post created: {d.get('id')}")
             if d.get("text"):
                 click.echo(f"  {d['text']}")
+            if d.get("cardSentToGroups"):
+                click.echo(f"  Card sent to: {', '.join(d['cardSentToGroups'])}")
         ctx.output(summary, _render)
     except Exception as e:
         ctx.handle_error(e)

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/core/chat.py

@@ -438,6 +438,159 @@ def send_group_message(
     return ack_data
 
 
+# The file-transfer assistant (文件传输助手) is a real 1-on-1 conversation
+# with a fixed pseudo-account id, not a shortcut for your own account
+# (pd-openweb src/pages/chat/utils/constant.js `FILE_TRANSFER.id`). It is
+# how the web client lets you message yourself.
+FILE_TRANSFER_ID = "file-transfer"
+
+
+def send_user_message(
+    session: Session,
+    to_user: str,
+    message: str,
+) -> Any:
+    """Send a 1-on-1 chat message over the socket, as the chat panel does.
+
+    ``send_message`` posts to the main-site ``Message.SendMessageToAccountIds``,
+    which addresses real *account ids* and silently drops anything else —
+    the caller's own id, and the file-transfer assistant, both come back
+    as ``successCount: 0`` with nothing stored.
+
+    The chat panel never uses that endpoint: it emits the socket.io event
+    ``'send message'`` with ``touser`` set to the conversation id
+    (``src/pages/chat/utils/socket.js`` ``Message.send`` USER branch;
+    ``containers/ChatPanelSession/index.js:152,334,357`` set
+    ``sendMsg.touser = session.id``). Because the target is a
+    conversation id rather than an account id, this path also reaches
+    :data:`FILE_TRANSFER_ID`, which is what "send to myself" means in the
+    web client.
+    """
+    import uuid
+
+    if not to_user:
+        raise ValueError("to_user is required")
+    if not message:
+        raise ValueError("message must not be empty")
+    payload = {
+        "type": MSGTYPE_TEXT,
+        "msg": message,
+        "touser": to_user,
+        "waitingid": str(uuid.uuid4()),
+    }
+    ack = _socket_emit(session, "send message", payload, strict=True)
+    if isinstance(ack, tuple) and len(ack) >= 2:
+        return ack[1]
+    return ack
+
+
+def withdraw_message(
+    session: Session,
+    message_id: str,
+    *,
+    group_id: str = "",
+    to_user: str = "",
+    time: str = "",
+    admin_account_id: str = "",
+) -> Any:
+    """Recall (撤回) a message you sent, in a group or a 1-on-1 chat.
+
+    Recall has no REST endpoint — pd-openweb emits a socket.io event
+    (``src/pages/chat/utils/socket.js`` ``Message.sendWithdrawMessgae``):
+    ``'withdraw group message'`` for a group, ``'withdraw user message'``
+    for a 1-on-1. The parameter object is built by
+    ``containers/Message/index.js::handleWithdrawMessage`` as
+    ``{messageId, groupid | touser, time}`` — note the lowercase
+    ``groupid`` / ``touser`` keys — plus ``adminid`` when a group admin
+    recalls somebody else's message.
+
+    Server-side limits, surfaced by the UI rather than by us: an author
+    can only recall within 5 minutes of sending
+    (``components/Message/MessageToolbar/index.js:285``), while a group
+    admin may recall another member's message with no time limit
+    (``:275-276``). A recall past the window is refused by the server.
+
+    Exactly one of ``group_id`` / ``to_user`` identifies the conversation.
+    """
+    if not message_id:
+        raise ValueError("message_id is required")
+    if bool(group_id) == bool(to_user):
+        raise ValueError("pass exactly one of group_id or to_user")
+    param: dict[str, Any] = {"messageId": message_id, "time": time or ""}
+    if group_id:
+        param["groupid"] = group_id
+        event = "withdraw group message"
+    else:
+        param["touser"] = to_user
+        event = "withdraw user message"
+    if admin_account_id:
+        param["adminid"] = admin_account_id
+    ack = _socket_emit(session, event, param, strict=True)
+    if isinstance(ack, tuple) and len(ack) >= 2:
+        return ack[1]
+    return ack
+
+
+def send_group_post_card(
+    session: Session,
+    group_id: str,
+    post_id: str,
+    title: str,
+    *,
+    post_type: int = 0,
+    server_url: str = "",
+) -> Any:
+    """Send a card linking to a post into a group chat.
+
+    This is a chat message about a post; it does not change who can see
+    the post itself (that is the post's own audience — see
+    ``hap_cli.core.post.add_post``).
+
+    Wire shape mirrors ``pd-openweb/src/pages/chat/utils/cardSender.js``
+    (``_initPost``): message ``type`` 5 (``Constant.MSGTYPE_CARD``) with a
+    ``card`` of ``{md, entityid, url, title, text}``, where ``md`` is
+    ``vote`` for a vote post (postType 7) and ``post`` otherwise, and the
+    url is ``/feeddetail?itemID=<postId>``. The title is capped at 300
+    characters, as the frontend does.
+
+    The ``msg`` line is the conversation-list summary, built the way
+    ``ChatPanelSession/index.js:277-278`` builds it: ``[<kind>] <title>``,
+    where the kind comes from the *localized* card name
+    (``cardDisposeName`` → ``_l('动态')`` / ``_l('投票')``). It is read by
+    other people in the chat, so it goes through the content-default
+    catalog rather than being hardcoded in one language.
+    """
+    import uuid
+
+    from hap_cli.i18n import content_default
+
+    if not group_id:
+        raise ValueError("group_id is required")
+    if not post_id:
+        raise ValueError("post_id is required")
+    card_title = (title or "")[:300]
+    is_vote = str(post_type) == "7"
+    kind = content_default("chat.vote" if is_vote else "chat.post")
+    base = (server_url or getattr(session, "server_url", "") or "").rstrip("/")
+    payload = {
+        "type": 5,
+        "msg": f"{kind} {card_title}",
+        "card": {
+            "md": "vote" if is_vote else "post",
+            "entityid": post_id,
+            "url": f"{base}/feeddetail?itemID={post_id}",
+            "title": card_title,
+            "text": "",
+        },
+        "togroup": group_id,
+        "waitingid": str(uuid.uuid4()),
+    }
+    ack = _socket_emit(session, "send group message", payload, strict=True)
+    if isinstance(ack, tuple) and len(ack) >= 2:
+        return ack[1]
+    return ack
+
+
 def send_group_files(
     session: Session,
     group_id: str,

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/core/post.py

@@ -207,19 +207,35 @@ def add_post(
 ) -> dict[str, Any]:
     """Create a post via ``Post.AddPost``.
 
-    ``scope`` is a ``PostShareScopeReq`` object — not an int. The
-    frontend (``pd-openweb/src/pages/feed/components/createFeed/index.js``)
-    posts ``{radioProjectIds, shareGroupIds, shareProjectIds}``. When
-    the caller doesn't pass ``scope`` we default to "share with the
-    given org only", which matches the UI's default for org-wide posts.
+    ``scope`` is a ``PostShareScopeReq`` object — not an int — and it is
+    what decides **who can see the post**. The frontend
+    (``pd-openweb/src/pages/feed/components/createFeed/index.js``) posts
+    ``{radioProjectIds, shareGroupIds, shareProjectIds}``:
+
+    * ``shareProjectIds: [<orgId>]`` — everyone in that organization.
+      This is the org-wide feed (index.js:267-270).
+    * ``shareGroupIds: [<groupId>]`` with ``shareProjectIds: []`` — only
+      that group's members. Posting into a group builds exactly this
+      (index.js:647-650).
+
+    ``project_id`` is the organization the post belongs to and is always
+    sent as ``projectId``; on its own it is *not* an audience. Audience
+    defaults to the whole organization only when the caller names no
+    audience at all — naming a group must never silently widen the post
+    to everyone, which is what an unconditional ``or [project_id]``
+    fallback used to do.
 
     Returns the raw ``{post, success}`` envelope.
     """
     if scope is None:
+        groups = list(share_group_ids or [])
+        orgs = list(share_project_ids or [])
+        if not groups and not orgs:
+            orgs = [project_id]
         scope = {
             "radioProjectIds": radio_project_ids,
-            "shareGroupIds": list(share_group_ids or []),
-            "shareProjectIds": list(share_project_ids or [project_id]),
+            "shareGroupIds": groups,
+            "shareProjectIds": orgs,
         }
     return session.api_call(
         "Post", "AddPost",

hap_cli-0.8.28/hap_cli/guide/en/post.md

@@ -0,0 +1,101 @@
+# Posting: audience and group-chat cards
+
+`hap post create` publishes a post. This topic covers the one thing that most
+easily goes wrong: the **audience** — **who can see the post** — and how that
+differs from sending a card about it into a group chat.
+
+> 🚨 Core risk of this topic: **getting the audience wrong is outward-facing
+> and cannot be taken back.** Confirm who will receive it before publishing;
+> never guess.
+
+## 1. Audience is who can see it
+
+Two options, both repeatable, and they can be combined:
+
+```bash
+--to-group <groupId>    # members of that group can see it
+--to-org   <orgId>      # everyone in that organization can see it (company-wide)
+```
+
+**With neither given, the post goes to everyone in the `--org-id`
+organization.** That is the widest audience, so posting to a single group
+always requires an explicit `--to-group`.
+
+```bash
+# one group only
+hap post create -m "text" --to-group 9ccde712-xxxx
+
+# everyone in the company
+hap post create -m "text" --to-org fe288386-xxxx
+```
+
+`--org-id` is **the organization the post belongs to**; on its own it is not an
+audience. Naming a `--to-group` does **not** additionally publish company-wide.
+
+### Only a group with the feed enabled can be an audience
+
+A plain chat group cannot receive a post. The server refuses with
+"选择了没有加入的群组" (you picked a group you have not joined), which is
+**misleading** — you are in the group; it simply has no feed. The CLI checks
+first and names the group instead. To check one: `hap group info <groupId>`
+and look at `isPost`. To merely drop a link into such a group, use
+`--card-to-group` below.
+
+To see who would receive it before sending:
+
+```bash
+hap post create -m "text" --to-group 9ccde712-xxxx --dry-run
+```
+
+### ⚠️ You cannot infer the audience from an existing post
+
+The read model returns `org_ids` on **every** post — it identifies the network
+the post belongs to and does **not** mean the post went company-wide. A
+group-only post and a company-wide post read back with the same `org_ids` and
+`groups`, so the two are **indistinguishable**.
+
+That means a request like "post it to the same audience as last time" cannot be
+satisfied by reading the previous post; the information is not there. Ask, or
+use `--dry-run` to put the audience in front of the person for confirmation.
+
+## 2. A group-chat card is a different thing
+
+Sending a card that links to a post into a group chat has **nothing to do with
+the audience**. It is just a chat message, and it does not let anyone see a post
+they could not already see.
+
+```bash
+# publish, and also drop a card into a group chat
+hap post create -m "text" --to-group 9ccde712-xxxx --card-to-group 7f694ec7-xxxx
+```
+
+`--card-to-group` is repeatable. The card renders in the chat as
+"[Post] <title>" (the label follows the active language) and links through
+to the post.
+
+One line to remember the difference: `--to-group` decides **who can see the
+post**; `--card-to-group` only **drops a link card into a chat**.
+
+**Deleting the post does not take back the card.** The two are independent: the
+card stays in the chat and then points at a post that no longer exists. To
+remove it too, recall that message with
+`hap chat recall <messageId> --group-id <groupId>` (your own messages within 5
+minutes of sending; a group admin can recall a member's message with no limit).
+
+## 3. Topic tags
+
+Writing `#tag#` in the body registers a topic (for example `#今日工作#`), which
+shows up in the post's categories. List available topics with `hap post topics`.
+
+## 4. Other common commands
+
+```bash
+hap post list                      # list posts
+hap post search -k "kw" --scope myself   # only your own posts
+hap post get <postId>              # one post with its comments
+hap post comment <postId> -m "..."  # comment
+hap post delete <postId>           # delete
+```
+
+`post search --scope` accepts: `org`, `user`, `myself`, `group` / `groups`,
+`fav`.

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/guide/index.json

@@ -24,6 +24,14 @@
         "zh-Hans": "顺着通知或讨论找到它所属的那条应用记录。"
       }
     },
+    {
+      "name": "post",
+      "title": {"en": "Posting and who sees it", "zh-Hans": "发动态与发布范围"},
+      "summary": {
+        "en": "Audience decides who can see a post, and you cannot read it back off an existing one. Group-chat cards are a separate thing.",
+        "zh-Hans": "发布范围决定谁能看到，且无法从旧动态读出来。群聊卡片是另一回事。"
+      }
+    },
     {
       "name": "approval",
       "title": {"en": "Todos and approvals", "zh-Hans": "待办与审批"},

hap_cli-0.8.28/hap_cli/guide/zh-Hans/post.md

@@ -0,0 +1,89 @@
+# 发动态：发布范围与群聊卡片
+
+`hap post create` 发布动态。本主题只讲一件最容易出事的事：**发布范围**——也就是
+**哪些人能看到这条动态**，以及它和「在群聊里发一张动态卡片」的区别。
+
+> 🚨 本主题核心风险：**发布范围一旦发错，是对外可见且不可撤回的。**
+> 发之前务必确认收件范围，不要靠猜。
+
+## 1. 发布范围 = 谁能看到
+
+两个选项，可以重复指定，也可以混用：
+
+```bash
+--to-group <群组ID>    # 该群组的成员能看到
+--to-org   <组织ID>    # 该组织的全体同事能看到（公司范围）
+```
+
+**两个都不给时，默认发给 `--org-id` 组织的全体同事。** 这是最大的那个范围，
+所以只发给某个群时必须显式写 `--to-group`。
+
+```bash
+# 只发给某个群
+hap post create -m "内容" --to-group 9ccde712-xxxx
+
+# 发给全体同事
+hap post create -m "内容" --to-org fe288386-xxxx
+```
+
+`--org-id` 是**这条动态归属的组织**，本身不是发布范围。指定了 `--to-group` 就
+**不会**再额外发给全体同事。
+
+### 只有开启了动态的群组能作为发布范围
+
+纯聊天群不能接收动态。服务端对此的报错是「选择了没有加入的群组」，**具有误导性**
+——你明明在群里，真实原因是这个群没开启动态功能。CLI 会先行检查并直接报出群名。
+想查某个群是否可用：`hap group info <群组ID>`，看 `isPost` 是否为 true。
+只是想在这种群里贴个链接，用下面的 `--card-to-group`。
+
+发之前想确认发给谁，先干跑：
+
+```bash
+hap post create -m "内容" --to-group 9ccde712-xxxx --dry-run
+```
+
+### ⚠️ 不能靠读旧动态来推断范围
+
+读接口返回的 `org_ids` **每条动态都有**，它表示这条动态属于哪个网络，
+**不代表发给了全体同事**。只发群组的动态和发全体同事的动态，读出来的
+`org_ids` / `groups` 是一样的，**无法区分**。
+
+所以「照着上一条日报的范围发」这个需求，**不能**通过读上一条动态来实现——
+读不出来。要么问清楚，要么用 `--dry-run` 把范围列出来让人确认。
+
+## 2. 群聊动态卡片：另一回事
+
+在群聊里发一张指向动态的卡片，和发布范围**没有关系**。它只是一条聊天消息，
+不会让原本看不到这条动态的人看到它。
+
+```bash
+# 发布并同时在某个群聊里发一张卡片
+hap post create -m "内容" --to-group 9ccde712-xxxx --card-to-group 7f694ec7-xxxx
+```
+
+`--card-to-group` 可以重复指定多个群。卡片在群里显示为「[动态] 标题」（该标签随语言设置变化），点击跳转到该动态。
+
+两者的区别记住一句话：`--to-group` 决定**谁能看到动态本身**，
+`--card-to-group` 只是**在群聊里贴一个链接卡片**。
+
+**删掉动态不会撤回卡片。** 两者是彼此独立的，删除动态后群里的卡片仍在，点进去
+指向一条已不存在的动态。要一并清掉，用 `hap chat recall <消息ID> --group-id <群组ID>`
+撤回那条卡片消息（自己的消息限发送后 5 分钟内，群管理员撤回他人消息不限时）。
+
+## 3. 话题标签
+
+正文里写 `#标签#` 会被识别为话题（例如 `#今日工作#`），发布后出现在动态的
+分类里。可用的话题用 `hap post topics` 查。
+
+## 4. 其它常用
+
+```bash
+hap post list                      # 动态列表
+hap post search -k "关键字" --scope myself   # 只搜自己发的
+hap post get <动态ID>              # 查看某条动态及评论
+hap post comment <动态ID> -m "..."  # 评论
+hap post delete <动态ID>           # 删除
+```
+
+`post search` 的 `--scope` 取值：`org` 组织、`user` 某人、`myself` 自己、
+`group` / `groups` 群组、`fav` 收藏。

{hap_cli-0.8.27 → hap_cli-0.8.28}/hap_cli/i18n.py

@@ -95,6 +95,18 @@ CONTENT_DEFAULTS: dict[str, dict[str, str]] = {
         "en": "[Video]", "zh-Hans": "[视频]", "zh-Hant": "[影片]",
         "ja": "[動画]",
     },
+    # Card messages carry the same kind of one-line summary, built by
+    # pd-openweb as `[<kind>] <title>` from the localized card name
+    # (chat/utils/index.js `cardDisposeName`, used at
+    # ChatPanelSession/index.js:277-278).
+    "chat.post": {
+        "en": "[Post]", "zh-Hans": "[动态]", "zh-Hant": "[動態]",
+        "ja": "[投稿]",
+    },
+    "chat.vote": {
+        "en": "[Vote]", "zh-Hans": "[投票]", "zh-Hant": "[投票]",
+        "ja": "[投票]",
+    },
     # Name given to the reverse control synthesized when a two-way
     # relation is paired and the caller supplied no name.
     "control.backRelation": {