lockbot 2.8.0__tar.gz → 2.9.1__tar.gz

{lockbot-2.8.0/python/lockbot.egg-info → lockbot-2.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockbot
-Version: 2.8.0
+Version: 2.9.1
 Summary: Cluster resource management bot for IM platforms
 Author-email: Jianbang Yang <yangjianbang112@gmail.com>
 License: MIT

{lockbot-2.8.0 → lockbot-2.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lockbot"
-version = "2.8.0"
+version = "2.9.1"
 description = "Cluster resource management bot for IM platforms"
 readme = "README.md"
 license = {text = "MIT"}

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/backend/app/bots/router.py

@@ -127,6 +127,33 @@ def _normalize_cluster_configs(cc):
     return cc
 
 
+def _get_node_keys(cc) -> set:
+    """Extract node key set from cluster_configs (any format)."""
+    if _is_device_array_format(cc):
+        return {item["node_key"] for item in cc}
+    if isinstance(cc, dict):
+        return set(cc.keys())
+    if isinstance(cc, list):
+        return set(cc)
+    return set()
+
+
+def _validate_node_aliases(config_overrides, cluster_configs):
+    """Raise HTTPException if NODE_ALIASES contains keys not in cluster_configs."""
+    if not config_overrides:
+        return
+    aliases = config_overrides.get("NODE_ALIASES")
+    if not aliases:
+        return
+    valid_keys = _get_node_keys(cluster_configs)
+    invalid = set(aliases.keys()) - valid_keys
+    if invalid:
+        raise HTTPException(
+            status_code=422,
+            detail=f"NODE_ALIASES contains keys not in cluster_configs: {sorted(invalid)}",
+        )
+
+
 def _device_dict_to_array(d: dict) -> list:
     """Convert DEVICE cluster_configs from dict to ordered array for API response.
 
@@ -214,6 +241,8 @@ def create_bot(
     if body.bot_type.upper() not in VALID_BOT_TYPES:
         raise HTTPException(status_code=422, detail=f"Invalid bot_type, must be one of {VALID_BOT_TYPES}")
 
+    _validate_node_aliases(body.config_overrides, body.cluster_configs)
+
     exists = (
         db.query(Bot)
         .filter(
@@ -349,6 +378,11 @@ def update_bot(
     if user.role != "super_admin" and bot.user_id != user.id:
         raise HTTPException(status_code=403, detail="Cannot edit another user's bot")
 
+    # Validate NODE_ALIASES keys against cluster_configs
+    if body.config_overrides and body.config_overrides.get("NODE_ALIASES"):
+        cc = body.cluster_configs if body.cluster_configs is not None else json.loads(bot.cluster_configs)
+        _validate_node_aliases(body.config_overrides, cc)
+
     changes = {}
     if body.name is not None:
         # Check for duplicate name (excluding current bot and deleted bots)

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/backend/app/bots/schemas.py

@@ -57,6 +57,21 @@ def _validate_config_overrides(v: dict | None) -> dict | None:
     if whitelist is not None and (not isinstance(whitelist, list) or not all(isinstance(u, str) for u in whitelist)):
         errors.append("DURATION_WHITELIST must be a list of strings")
 
+    node_aliases = v.get("NODE_ALIASES")
+    if node_aliases is not None and (
+        not isinstance(node_aliases, dict)
+        or not all(isinstance(k, str) and isinstance(a, str) and len(a) <= 15 for k, a in node_aliases.items())
+    ):
+        errors.append("NODE_ALIASES must be a dict of {string: string} with alias length <= 15")
+
+    show_alias = v.get("SHOW_NODE_ALIAS")
+    if show_alias is not None and not isinstance(show_alias, bool):
+        errors.append("SHOW_NODE_ALIAS must be a boolean")
+
+    allow_alias = v.get("ALLOW_USER_ALIAS")
+    if allow_alias is not None and not isinstance(allow_alias, bool):
+        errors.append("ALLOW_USER_ALIAS must be a boolean")
+
     max_dur = v.get("MAX_LOCK_DURATION")
     default_dur = v.get("DEFAULT_DURATION")
     if isinstance(max_dur, int) and isinstance(default_dur, int) and max_dur != -1 and default_dur > max_dur:

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/base_bot.py

@@ -121,6 +121,86 @@ class BaseLockBot:
         """
         return self.adapter.build_reply("\u274c" + error_msg, [user_id])
 
+    @property
+    def _duration_whitelist(self):
+        return self.config.get_val("DURATION_WHITELIST") or []
+
+    def _display_node(self, node_key):
+        """Return node_key with alias suffix if SHOW_NODE_ALIAS is enabled."""
+        if not self.config.get_val("SHOW_NODE_ALIAS"):
+            return node_key
+        aliases = self.config.get_val("NODE_ALIASES") or {}
+        alias = aliases.get(node_key)
+        return f"{node_key}「{alias}」" if alias else node_key
+
+    def alias(self, user_id, command):
+        """Set or clear a node alias. Usage: alias <node_key> [alias_value]"""
+        if not self.config.get_val("ALLOW_USER_ALIAS"):
+            return self.show_error(user_id, t("alias.disabled", config=self.config))
+
+        import re
+
+        m = re.match(r"^\s*alias\s+([\w\d_-]+)(?:\s+(.{1,15}))?\s*$", command)
+        if not m:
+            return self.show_error(user_id, t("alias.usage", config=self.config))
+
+        node_key = m.group(1)
+        alias_val = (m.group(2) or "").strip()
+
+        cluster_configs = self.config.get_val("CLUSTER_CONFIGS")
+        if node_key not in cluster_configs:
+            return self.show_error(
+                user_id,
+                t(
+                    "alias.invalid_node",
+                    config=self.config,
+                    node_key=node_key,
+                    valid_keys=str(list(cluster_configs.keys())),
+                ),
+            )
+
+        aliases = self.config.get_val("NODE_ALIASES") or {}
+        if alias_val:
+            aliases[node_key] = alias_val
+        else:
+            aliases.pop(node_key, None)
+        self.config.set_val("NODE_ALIASES", aliases)
+
+        # Persist to DB if running under platform mode
+        self._persist_config_override("NODE_ALIASES", aliases)
+
+        if alias_val:
+            self.logger.info("user=%s set alias %s -> %s", user_id, node_key, alias_val)
+            msg = t("alias.set_ok", config=self.config, node_key=node_key, alias=alias_val)
+        else:
+            self.logger.info("user=%s cleared alias %s", user_id, node_key)
+            msg = t("alias.clear_ok", config=self.config, node_key=node_key)
+        return self.adapter.build_reply(msg, [user_id])
+
+    def _persist_config_override(self, key, value):
+        """Persist a single config_override key to DB (best-effort)."""
+        try:
+            import json
+
+            from lockbot.backend.app.bots.models import Bot
+            from lockbot.backend.app.database import SessionLocal
+
+            bot_id = self.config.get_val("BOT_ID")
+            if not bot_id:
+                return
+            db = SessionLocal()
+            try:
+                bot = db.query(Bot).filter(Bot.id == int(bot_id)).first()
+                if bot:
+                    overrides = json.loads(bot.config_overrides) if bot.config_overrides else {}
+                    overrides[key] = value
+                    bot.config_overrides = json.dumps(overrides, ensure_ascii=False)
+                    db.commit()
+            finally:
+                db.close()
+        except Exception:
+            pass
+
     def _whitelist_hint(self):
         """Return whitelist hint string if BOT_OWNER is configured, else empty string."""
         owner = self.config.get_val("BOT_OWNER")

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/device_bot.py

@@ -39,7 +39,7 @@ class DeviceBot(BaseLockBot):
         _loader = staticmethod(create_or_load_device_state)
 
     def supported_commands(self):
-        return ["lock", "slock", "unlock", "free", "kickout", "help", "h", "query"]
+        return ["lock", "slock", "unlock", "free", "kickout", "help", "h", "query", "alias"]
 
     def parse_command(self, user_id, command_key, command, parsing_duration=False):
         """
@@ -177,7 +177,7 @@ class DeviceBot(BaseLockBot):
             return error_reply
 
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             timestamp = int(time.time())
 
@@ -251,7 +251,7 @@ class DeviceBot(BaseLockBot):
             return error_reply
 
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             timestamp = int(time.time())
             for node_key, dev_ids in zip(node_key_list, dev_ids_list, strict=True):
@@ -493,6 +493,9 @@ class DeviceBot(BaseLockBot):
         text += t("help.query_node_example", config=self.config, node=example_node)
         text += "\n"
 
+        if self.config.get_val("ALLOW_USER_ALIAS"):
+            text += f"6. 备注: alias {example_node} <备注>\n\n"
+
         return text
 
     def _check_and_notify(self) -> float | None:
@@ -597,4 +600,6 @@ class DeviceBot(BaseLockBot):
         """
         Get a text description of the current cluster device usage (supports merged display and heterogeneous hints).
         """
-        return get_current_usage(node_filter, self.state.bot_state, {}, config=self.config)
+        return get_current_usage(
+            node_filter, self.state.bot_state, {}, config=self.config, display_node=self._display_node
+        )

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/device_usage_utils.py

@@ -157,7 +157,7 @@ def render_device_lines(node_status, grouped_usage, idle_groups, config=None):
     return lines
 
 
-def get_current_usage(node_filter, bot_state, monitor_status, config=None):
+def get_current_usage(node_filter, bot_state, monitor_status, config=None, display_node=None):
     """
     Get current device usage info including idle, locked, and in-use devices.
     """
@@ -169,7 +169,8 @@ def get_current_usage(node_filter, bot_state, monitor_status, config=None):
             or node_key == node_filter
             or (isinstance(node_filter, list) and node_key in node_filter)
         ):
-            usage_info += t("device_usage.node_header", config=config, node_key=node_key)
+            shown_name = display_node(node_key) if display_node else node_key
+            usage_info += t("device_usage.node_header", config=config, node_key=shown_name)
 
             grouped_usage = group_locked_devices(node_status)
             shown_indices = set()

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/handler.py

@@ -55,6 +55,8 @@ def execute_command(msg_data, bot):
             return bot.query(user_id)
     elif cmd in ("help", "h"):
         return bot.print_help(user_id)
+    elif cmd == "alias":
+        return bot.alias(user_id, rcv_info)
     else:
         return bot.print_help(user_id, t("error.unknown_error", config=getattr(bot, "config", None), command=rcv_info))
         return bot.print_help(user_id, t("error.unknown_error", config=getattr(bot, "config", None), command=rcv_info))

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/i18n/en.py

@@ -173,6 +173,12 @@ MESSAGES = {
     "opkick.invalid_format": "Invalid opkick format. Usage: opkick <username> [node] [dev x,y]",
     "opkick.notify_kicked": "⚠️ [Operator Release]\n\nNode: {node_key}\n",
     "opkick.notify_kicked_reason": "Reason: {reason}\n\n",
+    # ── Alias command ──
+    "alias.usage": "Usage: alias <node_key> [label]\nExample: alias node0 10.10.10.56\nClear: alias node0",
+    "alias.invalid_node": "Node {node_key} does not exist. Available: {valid_keys}\n",
+    "alias.set_ok": "✅ Set {node_key} alias to「{alias}」\n\n",
+    "alias.clear_ok": "✅ Cleared alias for {node_key}\n\n",
+    "alias.disabled": "User alias command is not enabled for this bot",
     # ── Webhook: bot not running ──
     "webhook.bot_not_running": "⚠️ Bot {bot_name}(ID:{bot_id}) is not running. "  # noqa: E501
     "Please contact the owner @{owner_username} to start it.",

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/i18n/zh.py

@@ -166,6 +166,12 @@ MESSAGES = {
     "opkick.invalid_format": "opkick命令格式错误，正确格式: opkick <username> [node] [dev x,y]",
     "opkick.notify_kicked": "⚠️【运维释放】\n\n节点: {node_key}\n",
     "opkick.notify_kicked_reason": "原因: {reason}\n\n",
+    # ── Alias command ──
+    "alias.usage": "用法: alias <节点名> [备注]\n示例: alias node0 10.10.10.56\n清除: alias node0",
+    "alias.invalid_node": "节点 {node_key} 不存在，可用节点: {valid_keys}\n",
+    "alias.set_ok": "✅ 已设置 {node_key} 备注为「{alias}」\n\n",
+    "alias.clear_ok": "✅ 已清除 {node_key} 的备注\n\n",
+    "alias.disabled": "该机器人未开启用户自助设置备注功能",
     # ── Webhook: bot not running ──
     "webhook.bot_not_running": (
         "⚠️ 机器人 {bot_name}(ID:{bot_id}) 尚未启动，请联系管理人 @{owner_username} 启动后再使用。"

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/node_bot.py

@@ -37,7 +37,7 @@ class NodeBot(BaseLockBot):
         _loader = staticmethod(create_or_load_node_state)
 
     def supported_commands(self):
-        return ["lock", "slock", "unlock", "free", "kickout", "help", "h", "query"]
+        return ["lock", "slock", "unlock", "free", "kickout", "help", "h", "query", "alias"]
 
     def parse_command(self, user_id, command_key, command, parsing_duration=False):
         """
@@ -111,7 +111,7 @@ class NodeBot(BaseLockBot):
             return error_reply
 
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             nodes = [self.state.bot_state[node_key] for node_key in node_keys]
             if not all(
@@ -171,7 +171,7 @@ class NodeBot(BaseLockBot):
             return error_reply
 
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             nodes = [self.state.bot_state[node_key] for node_key in node_keys]
             if not all(node["status"] != "exclusive" for node in nodes):
@@ -358,7 +358,12 @@ class NodeBot(BaseLockBot):
         reply_info += t("help.section4_title", config=self.config)
         reply_info += t("help.section5_title", config=self.config)
         reply_info += t("help.query_at_bot", config=self.config)
-        reply_info += f"    {example_node0}\n\n"
+        reply_info += f"    {example_node0}\n"
+
+        if self.config.get_val("ALLOW_USER_ALIAS"):
+            reply_info += f"6. 备注: alias {example_node0} <备注>\n"
+
+        reply_info += "\n"
         return reply_info
 
     def _check_and_notify(self) -> float | None:
@@ -397,7 +402,7 @@ class NodeBot(BaseLockBot):
 
                                 uid = user_info["user_id"] + format_access_mode(node["status"], config=self.config)
                                 duration = format_duration(remaining_time, config=self.config)
-                                alert_info += f"{node_key} {uid}  {duration}\n"
+                                alert_info += f"{self._display_node(node_key)} {uid}  {duration}\n"
 
                         if EARLY_NOTIFY and not user_info["is_notified"] and 0 < remaining_time <= TIME_ALERT:
                             trigger_time_alert = True
@@ -407,7 +412,7 @@ class NodeBot(BaseLockBot):
 
                             uid = user_info["user_id"] + format_access_mode(node["status"], config=self.config)
                             duration = format_duration(remaining_time, config=self.config)
-                            alert_info += f"{node_key} {uid}  {duration}\n"
+                            alert_info += f"{self._display_node(node_key)} {uid}  {duration}\n"
 
                     for user_id in removed_users_id:
                         remove_user_info(node["current_users"], user_id)
@@ -453,11 +458,12 @@ class NodeBot(BaseLockBot):
             usage_info = ""
             for node_key, node_status in nodes.items():
                 if node_filter is None or node_key == node_filter:
+                    display_name = self._display_node(node_key)
                     if node_status["status"] == "idle":
-                        usage_info += "{:} {}\n".format(node_key, t("status.idle", config=self.config))
+                        usage_info += "{:} {}\n".format(display_name, t("status.idle", config=self.config))
                     else:
                         for user_idx, user_info in enumerate(node_status["current_users"]):
-                            node_name = f"{node_key}" if user_idx == 0 else ""
+                            node_name = f"{display_name}" if user_idx == 0 else ""
                             uid = user_info["user_id"] + format_access_mode(node_status["status"], config=self.config)
                             duration = format_duration(
                                 remaining_duration(user_info["start_time"], user_info["duration"]), config=self.config

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/queue_bot.py

@@ -26,7 +26,7 @@ class QueueBot(NodeBot):
     """
 
     def supported_commands(self):
-        return ["lock", "unlock", "free", "kickout", "kicklock", "help", "h", "book", "take", "query"]
+        return ["lock", "unlock", "free", "kickout", "kicklock", "help", "h", "book", "take", "query", "alias"]
 
     def lock(self, user_id, command):
         """
@@ -38,7 +38,7 @@ class QueueBot(NodeBot):
             return error_reply
 
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             nodes = [self.state.bot_state[node_key] for node_key in node_keys]
             if not all(
@@ -132,7 +132,7 @@ class QueueBot(NodeBot):
             return error_reply
 
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             nodes = [self.state.bot_state[node_key] for node_key in node_keys]
             if any(
@@ -174,7 +174,7 @@ class QueueBot(NodeBot):
         content = t("success.take_success_by", config=self.config, user_id=user_id)
         content += self._msg_with_usage("label.before_take")
         max_dur = self.config.get_val("MAX_LOCK_DURATION")
-        whitelist = self.config.get_val("DURATION_WHITELIST") or []
+        whitelist = self._duration_whitelist
         with self._lock:
             nodes = [self.state.bot_state[node_key] for node_key in node_keys]
             if any(find_user_info(node["current_users"], user_id) for node in nodes):
@@ -345,7 +345,12 @@ class QueueBot(NodeBot):
         parts.append(t("help.section_help_title_queue", config=self.config))
         parts.append(t("help.section_query_title_queue", config=self.config))
         parts.append(t("help.query_at_bot", config=self.config))
-        parts.append(f"    {example_node0}\n\n")
+        parts.append(f"    {example_node0}\n")
+
+        if self.config.get_val("ALLOW_USER_ALIAS"):
+            parts.append(f"8. 备注: alias {example_node0} <备注>\n")
+
+        parts.append("\n")
         return "".join(parts)
 
     def _check_and_notify(self) -> float | None:
@@ -522,11 +527,12 @@ class QueueBot(NodeBot):
             usage_info = ""
             for node_key, node_status in nodes.items():
                 if node_filter is None or node_key == node_filter:
+                    display_name = self._display_node(node_key)
                     if node_status["status"] == "idle":
-                        usage_info += "{:} {}\n".format(node_key, t("status.idle", config=self.config))
+                        usage_info += "{:} {}\n".format(display_name, t("status.idle", config=self.config))
                     else:
                         for user_idx, user_info in enumerate(node_status["current_users"]):
-                            node_name = f"{node_key}" if user_idx == 0 else ""
+                            node_name = f"{display_name}" if user_idx == 0 else ""
                             uid = user_info["user_id"]
                             duration = format_duration(
                                 remaining_duration(user_info["start_time"], user_info["duration"]),

{lockbot-2.8.0 → lockbot-2.9.1}/python/lockbot/core/utils.py

@@ -77,7 +77,8 @@ def apply_max_duration_limit(user_list, max_duration, whitelist=None):
     Returns a list of user_ids whose durations were clamped.
     Whitelist users are skipped.
     """
-    whitelist = whitelist or []
+    if whitelist is None:
+        whitelist = []
     clamped_users = []
     for user_info in user_list:
         if user_info["user_id"] in whitelist:

{lockbot-2.8.0 → lockbot-2.9.1/python/lockbot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockbot
-Version: 2.8.0
+Version: 2.9.1
 Summary: Cluster resource management bot for IM platforms
 Author-email: Jianbang Yang <yangjianbang112@gmail.com>
 License: MIT