netizen-cli 0.11.3__tar.gz → 0.11.5__tar.gz

{netizen_cli-0.11.3/netizen_cli.egg-info → netizen_cli-0.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netizen-cli
-Version: 0.11.3
+Version: 0.11.5
 Summary: Use native Codex threads through a Feishu Channel.
 Requires-Python: <3.15,>=3.11
 Requires-Dist: h11==0.16.0

{netizen_cli-0.11.3 → netizen_cli-0.11.5}/netizen_cli/__init__.py

@@ -1,3 +1,3 @@
 """Netizen: a thin Feishu Channel for native Codex Threads."""
 
-__version__ = "0.11.3"
+__version__ = "0.11.5"

{netizen_cli-0.11.3 → netizen_cli-0.11.5}/netizen_cli/cards/callbacks.py

@@ -76,7 +76,7 @@ _REPEATABLE_CARD_CONTROL_NAMES = frozenset(
 # one updated message. Revision-bearing and one-shot actions stay excluded.
 _REPEATABLE_CALLBACK_INTENTS = frozenset(
     name.value for name in _REPEATABLE_CARD_CONTROL_NAMES
-) | {TurnFileActionName.PAGE.value}
+) | {TurnFileActionName.PAGE.value, "status.command"}
 
 
 class CardActionError(ValueError):
@@ -453,15 +453,15 @@ def _builder(title: str, subtitle: str, *, template: str = "blue"):
     )
 
 
-def _button_row(*buttons: dict[str, Any]) -> dict[str, Any]:
+def _button_row(*buttons: dict[str, Any], equal_width: bool = True) -> dict[str, Any]:
     return {
         "tag": "column_set",
         "flex_mode": "none",
         "columns": [
             {
                 "tag": "column",
-                "width": "weighted",
-                "weight": 1,
+                "width": "weighted" if equal_width else "auto",
+                **({"weight": 1} if equal_width else {}),
                 "elements": [button],
             }
             for button in buttons

{netizen_cli-0.11.3 → netizen_cli-0.11.5}/netizen_cli/cards/chat_target.py

@@ -221,7 +221,8 @@ def snapshot_capacity_selections(snapshot: ChatSearchSnapshot, page: int) -> tup
 
 def chat_target_elements(*, mode_field: str, choice_field: str, id_field: str,
                          draft: ChatTargetDraft, options: Sequence[dict[str, Any]],
-                         search: ChatSearchView | None = None) -> list[dict[str, Any]]:
+                         search: ChatSearchView | None = None,
+                         group_details: bool = False) -> list[dict[str, Any]]:
     """Both inputs remain editable; the mode alone determines the saved value."""
     if draft.mode not in {"current", "group", "id"}:
         raise CardActionError("请选择有效的飞书聊天指定方式。")
@@ -246,11 +247,13 @@ def chat_target_elements(*, mode_field: str, choice_field: str, id_field: str,
              {"text": _plain_text("填写聊天 ID"), "value": "id"},
          ], "initial_option": draft.mode},
     ]
-    elements.append(_plain("群聊选择（仅选择群聊时生效）"))
+    if not group_details or search is None:
+        elements.append(_plain("选择群聊" if group_details else "群聊选择（仅选择群聊时生效）"))
     if search is not None:
         elements.extend([
             {"tag": "input", "name": search.query_field, "required": False,
-             "width": "fill", "max_length": 50, "label": _plain_text("查找群聊 · 群名关键词"),
+             "width": "fill", "max_length": 50,
+             "label": _plain_text("群聊 · 群名关键词" if group_details else "查找群聊 · 群名关键词"),
              "default_value": search.query, "placeholder": _plain_text("留空查找全部可选群")},
             search.search_button,
         ])
@@ -261,7 +264,7 @@ def chat_target_elements(*, mode_field: str, choice_field: str, id_field: str,
             elements.append(_plain(f"查找结果 · {query_label}{page_label}。修改关键词后请重新点击查找群聊。"))
         elif choices:
             elements.append(_plain("当前选择；如需其他群，请先查找群聊。"))
-        else:
+        elif not group_details:
             elements.append(_plain("请先查找群聊，再从查找结果中选择。"))
     if choices or search is None:
         if search is not None and draft.choice and "initial_option" in choice:
@@ -272,11 +275,31 @@ def chat_target_elements(*, mode_field: str, choice_field: str, id_field: str,
         elements.append(_plain("没有找到可选群聊，请修改关键词重新查找。"))
     if search is not None and search.navigation is not None:
         elements.append(search.navigation)
-    elements.extend([
+    elements.append(
         {"tag": "input", "name": id_field, "required": False, "width": "fill",
-         "label": _plain_text("聊天 ID（仅填写 ID 时生效）"),
+         "label": _plain_text("聊天 ID" if group_details else "聊天 ID（仅填写 ID 时生效）"),
          "default_value": draft.chat_id, "max_length": 192,
-         "placeholder": _plain_text("请输入聊天 ID（oc_…），不能为空")},
+         "placeholder": _plain_text("oc_…" if group_details else "请输入聊天 ID（oc_…），不能为空")},
+    )
+    if group_details:
+        elements.append({
+            "tag": "markdown", "text_size": "notation",
+            "content": "<font color='grey'>请使用聊天 ID，非用户 ID；单聊限与本机器人的聊天。</font>"
+                f"[获取 ID]({CHAT_ID_HELP_URL})",
+        })
+        mode, *details = elements
+        return [mode, {
+            "tag": "column_set", "flex_mode": "none", "background_style": "grey-50",
+            "columns": [{
+                "tag": "column", "width": "weighted", "weight": 1,
+                "padding": "12px", "vertical_spacing": "8px",
+                "elements": [{
+                    "tag": "markdown", "text_size": "notation",
+                    "content": "<font color='grey'>当前聊天无需填写；其他方式只需填写对应项。</font>",
+                }, *details],
+            }],
+        }]
+    elements.extend([
         _plain("仅指定方式对应的输入生效；填写 ID 时不能为空。聊天 ID 不是用户 ID；单聊请选择与本机器人的聊天。"),
         {"tag": "markdown", "content": f"[如何获取聊天 ID]({CHAT_ID_HELP_URL})"},
     ])

{netizen_cli-0.11.3 → netizen_cli-0.11.5}/netizen_cli/cards/fork.py

@@ -293,11 +293,11 @@ def fork_form_card(scope: FeishuScope, source: ForkSource, *, source_title: str,
             {"tag": "input", "name": _NAME_FIELD, "width": "fill",
              "label": _plain_text("分支名称"), "default_value": draft_name,
              "max_length": MAX_THREAD_NAME_CHARS},
-            _plain("目标飞书聊天 · 在所选聊天中新建分支话题"),
+            {"tag": "markdown", "content": "**分支位置**\n<font color='grey'>在所选聊天中新建分支话题</font>"},
             *chat_target_elements(
                 mode_field=_MODE_FIELD, choice_field=_TARGET_FIELD, id_field=_ID_FIELD,
                 draft=ChatTargetDraft(target.mode, selection, target.chat_id), options=page_options,
-                search=search,
+                search=search, group_details=True,
             ),
             _button(scope, source, "创建分支", "create"),
         ]
@@ -327,14 +327,16 @@ def fork_status_card(*, name: str, source_title: str, project_alias: str,
                      topic_url: str | None = None, detail: str | None = None,
                      native_thread_id: str | None = None,
                      binding_saved: bool = False) -> OutboundCard:
-    """One target root card is updated in place; status pages cannot resubmit."""
+    """Status pages cannot resubmit; only the source receipt gets a topic URL."""
     titles = {"creating": "会话分支创建中", "success": "会话分支已创建", "failed": "会话分支创建未完成"}
-    builder = _builder(titles[status], name, template="red" if status == "failed" else "blue")
+    title, subtitle = (name, titles[status]) if status == "success" else (titles[status], name)
+    builder = _builder(title, subtitle, template="red" if status == "failed" else "blue")
     builder.raw(_plain(f"来源：{source_title}\nProject：{project_alias}"))
     if status == "creating":
         builder.raw(_notice("请等待创建完成后再发送消息。"))
     elif status == "success":
-        builder.raw(_plain("在新话题中发送消息即可继续。两个会话独立管理，共享项目文件；来源会话保持不变。"))
+        location = "新话题" if topic_url else "本话题"
+        builder.raw(_plain(f"在{location}中发送消息即可继续。两个会话独立管理，共享项目文件；来源会话保持不变。"))
         if topic_url:
             builder.raw({"tag": "button", "text": _plain_text("进入新话题"), "type": "primary_filled",
                 "behaviors": [{"type": "open_url", "default_url": topic_url}]})

{netizen_cli-0.11.3 → netizen_cli-0.11.5}/netizen_cli/cards/reply.py

@@ -1059,7 +1059,6 @@ def _turn_progress_panel(
         },
         "elements": _turn_activity_elements(
             snapshot,
-            status_label=status_label,
             hidden_steps=hidden_steps,
             goal=goal,
         ),
@@ -1087,11 +1086,10 @@ def _progress_status_label(
 def _turn_activity_elements(
     snapshot: _TurnActivitySnapshotLike,
     *,
-    status_label: str,
     hidden_steps: int = 0,
     goal: bool = False,
 ) -> list[dict[str, Any]]:
-    elements = [_plain(f"状态：{status_label}")]
+    elements: list[dict[str, Any]] = []
     if snapshot.steer_count:
         elements.append(_plain(f"已接收调整：{snapshot.steer_count} 次"))
     commentary = tuple(getattr(snapshot, "commentary", ()))[

netizen_cli-0.11.5/netizen_cli/cards/status.py

@@ -0,0 +1,239 @@
+"""Session snapshots with a closed set of session-bound command aliases."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from lark_channel import OutboundCard
+
+from ..domain import ControlIntent, ControlName, FeishuScope
+from .callbacks import (
+    CardActionError, _builder, _button_row, _repeatable_callback_button, _plain,
+    _plain_text, _required_string,
+)
+
+
+_STATUS_COMMAND = "status.command"
+_STATUS_CARD_MAX_BYTES = 55_000
+_BINDING_COMMANDS = (
+    ("查看状态", ControlName.STATUS, ()),
+    ("停止", ControlName.STOP, ()),
+    ("会话配置", ControlName.CONFIG, ()),
+    ("会话列表", ControlName.SESSIONS, ()),
+)
+_SIDE_COMMANDS = (
+    ("查看状态", ControlName.STATUS, ()),
+    ("停止", ControlName.STOP, ()),
+    ("结束临时会话", ControlName.SIDE, ("close",)),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class StatusCommandAction:
+    target_kind: str
+    target_id: str
+    command: ControlIntent
+    snapshot: dict[str, Any]
+
+    def card(self) -> OutboundCard:
+        """Renew transport nonces while preserving the original display snapshot."""
+        if self.target_kind == "side":
+            return side_status_card(scope=self.command.scope, side_id=self.target_id, **self.snapshot)
+        return session_status_card(scope=self.command.scope, binding_id=self.target_id, **self.snapshot)
+
+
+def is_status_command(value: Any) -> bool:
+    return isinstance(value, Mapping) and value.get("intent") == _STATUS_COMMAND
+
+
+def decode_status_command(
+    *, scope: FeishuScope, message_id: str, sender_id: str, value: Any,
+) -> StatusCommandAction:
+    fields = {"v", "intent", "scope", "target_kind", "target_id", "command", "snapshot"}
+    if isinstance(value, Mapping):
+        value = {key: item for key, item in value.items() if key != "nonce"}
+    if not isinstance(value, Mapping) or set(value) != fields:
+        raise CardActionError("状态卡操作无效，请重新发送 /status。")
+    if type(value["v"]) is not int or value["v"] != 1 or not is_status_command(value):
+        raise CardActionError("状态卡版本已过期，请重新发送 /status。")
+    if value["scope"] != scope.key:
+        raise CardActionError("状态卡与当前聊天或话题不一致，本次未执行。")
+    target_kind = value["target_kind"]
+    if target_kind not in ("binding", "side"):
+        raise CardActionError("状态卡会话类型无效，请重新发送 /status。")
+    commands = _SIDE_COMMANDS if target_kind == "side" else _BINDING_COMMANDS
+    selected = next((item for item in commands if item[1].value == value["command"]), None)
+    if selected is None:
+        raise CardActionError("状态卡不支持这个命令，请重新发送 /status。")
+    return StatusCommandAction(
+        target_kind=target_kind,
+        target_id=_required_string(value["target_id"], "target_id"),
+        command=ControlIntent(
+            scope=scope, source_id=_required_string(message_id, "message_id"),
+            sender_id=_required_string(sender_id, "sender_id"),
+            name=selected[1], arguments=selected[2],
+        ),
+        snapshot=_decode_snapshot(target_kind, value["snapshot"]),
+    )
+
+
+def _decode_snapshot(target_kind: str, value: Any) -> dict[str, Any]:
+    # Only inert display strings cross the callback. Never accept raw card JSON,
+    # and never use these historical labels as command admission or identity.
+    if target_kind == "side":
+        strings = {"short_id", "parent_short_id", "state", "turn_state"}
+        lines = {"git_branch_lines": 1}
+    else:
+        strings = {"short_id", "project_alias", "native_thread_id", "state", "context_window_line", "subscription_line"}
+        lines = {"metadata_lines": 2, "git_branch_lines": 1, "context_mode_lines": 4, "model_lines": 4, "progress_lines": 32}
+    if not isinstance(value, Mapping) or set(value) != strings | lines.keys():
+        raise CardActionError("状态卡展示快照无效，请重新发送 /status。")
+    if any(not isinstance(value[key], str) for key in strings):
+        raise CardActionError("状态卡展示文字无效，请重新发送 /status。")
+    for key, limit in lines.items():
+        items = value[key]
+        if (not isinstance(items, (list, tuple)) or len(items) > limit
+                or any(not isinstance(item, str) for item in items)):
+            raise CardActionError("状态卡展示字段无效，请重新发送 /status。")
+    if target_kind == "binding" and (len(value["metadata_lines"]) != 2 or len(value["model_lines"]) != 4):
+        raise CardActionError("状态卡展示字段缺失，请重新发送 /status。")
+    return dict(value)
+
+
+def _command_buttons(
+    scope: FeishuScope, target_kind: str, target_id: str, snapshot: dict[str, Any],
+) -> dict[str, Any]:
+    commands = _SIDE_COMMANDS if target_kind == "side" else _BINDING_COMMANDS
+    return _button_row(*(
+        _repeatable_callback_button(label=label, value={
+            "v": 1, "intent": _STATUS_COMMAND, "scope": scope.key,
+            "target_kind": target_kind, "target_id": target_id,
+            "command": command.value,
+            "snapshot": snapshot,
+        })
+        for label, command, _arguments in commands
+    ), equal_width=False)
+
+
+def _status_card(card: dict[str, Any]) -> OutboundCard:
+    # The snapshot appears in each button. Check the complete transport payload,
+    # including non-ASCII text, rather than just the visible body or one action.
+    if len(json.dumps(card, ensure_ascii=False).encode("utf-8")) > _STATUS_CARD_MAX_BYTES:
+        raise CardActionError("状态卡内容过长，暂不能展示；可直接使用 /stop、/config 或 /sessions。")
+    return OutboundCard(card=card)
+
+
+def session_status_card(
+    *,
+    scope: FeishuScope,
+    binding_id: str,
+    short_id: str,
+    project_alias: str,
+    native_thread_id: str,
+    state: str,
+    metadata_lines: tuple[str, str],
+    git_branch_lines: tuple[str, ...],
+    context_window_line: str,
+    context_mode_lines: tuple[str, ...],
+    model_lines: tuple[str, str, str, str],
+    progress_lines: tuple[str, ...],
+    subscription_line: str,
+) -> OutboundCard:
+    builder = _builder("当前会话", metadata_lines[0], template=_state_template(state))
+    builder.raw(_columns(f"Project：{project_alias}", f"状态：{state}"))
+    builder.raw(_plain(metadata_lines[1]))
+    for line in git_branch_lines:
+        builder.raw(_plain(line))
+
+    builder.raw({"tag": "hr"})
+    builder.markdown("**模型配置**")
+    builder.raw(_plain(model_lines[0]))
+    builder.raw(_columns(model_lines[1], model_lines[2]))
+    builder.raw(_plain(model_lines[3]))
+
+    builder.raw({"tag": "hr"})
+    builder.raw(_plain(context_window_line))
+    for line in context_mode_lines:
+        builder.raw(_plain(line))
+    if progress_lines:
+        builder.raw({"tag": "hr"})
+        builder.markdown("**任务进展**")
+        builder.raw(_plain("\n".join(progress_lines[1:])))
+
+    builder.raw({
+        "tag": "collapsible_panel",
+        "expanded": False,
+        "header": {"title": _plain_text("会话详情与订阅")},
+        "elements": [_plain("\n".join((
+            f"会话：{short_id}",
+            f"Native Thread：{native_thread_id}",
+            subscription_line,
+        )))],
+    })
+    builder.raw(_command_buttons(scope, "binding", binding_id, {
+        "short_id": short_id, "project_alias": project_alias,
+        "native_thread_id": native_thread_id, "state": state,
+        "metadata_lines": metadata_lines, "git_branch_lines": git_branch_lines,
+        "context_window_line": context_window_line, "context_mode_lines": context_mode_lines,
+        "model_lines": model_lines, "progress_lines": progress_lines,
+        "subscription_line": subscription_line,
+    }))
+    builder.markdown("<font color='grey'>本次查询快照 · 按钮与对应命令的处理方式相同</font>")
+    return _status_card(builder.to_dict())
+
+
+def side_status_card(
+    *,
+    scope: FeishuScope,
+    side_id: str,
+    short_id: str,
+    parent_short_id: str,
+    state: str,
+    turn_state: str,
+    git_branch_lines: tuple[str, ...],
+) -> OutboundCard:
+    # A Side's lifecycle and current Turn are distinct observations.
+    template_state = turn_state if state == "open" else state
+    builder = _builder("当前 Side", f"Side：{short_id}", template=_state_template(template_state))
+    builder.raw(_columns(f"状态：{state}", f"当前 Turn：{turn_state}"))
+    builder.raw(_plain(f"Parent 会话：{parent_short_id}"))
+    for line in git_branch_lines:
+        builder.raw(_plain(line))
+    builder.raw({"tag": "hr"})
+    builder.raw(_plain("空闲 2 小时后自动结束；运行中的 Turn 不计入空闲时间。"))
+    builder.raw(_command_buttons(scope, "side", side_id, {
+        "short_id": short_id, "parent_short_id": parent_short_id,
+        "state": state, "turn_state": turn_state, "git_branch_lines": git_branch_lines,
+    }))
+    builder.markdown("<font color='grey'>本次查询快照 · 按钮与对应命令的处理方式相同</font>")
+    return _status_card(builder.to_dict())
+
+
+def _columns(*values: str) -> dict[str, Any]:
+    return {
+        "tag": "column_set",
+        "flex_mode": "none",
+        "background_style": "grey-50",
+        "columns": [
+            {
+                "tag": "column", "width": "weighted", "weight": 1,
+                "padding": "8px", "elements": [_plain(value)],
+            }
+            for value in values
+        ],
+    }
+
+
+def _state_template(state: str) -> str:
+    if state in {"idle", "open", "goal-complete"}:
+        return "green"
+    if state in {"running", "goal-starting", "goal-running", "compacting", "creating"}:
+        return "blue"
+    if state == "failed":
+        return "red"
+    if state in {"closed", "expired"}:
+        return "grey"
+    return "orange"