Feat: chat channels — connect assistants to external messaging bots (#15850)

### What problem does this PR solve?

#15844

Adds a **Chat channels** capability so a RAGFlow assistant (Dialog) can
be exposed as a bot on external messaging platforms (Feishu/Lark,
Discord, Telegram, Slack, WeCom, LINE, etc.). An admin configures a bot
in the UI, connects it to an assistant, and inbound messages are
answered from that assistant's knowledge base — replies are delivered
back on the channel.

**Feishu/Lark is implemented and tested end-to-end.** Discord, Telegram,
LINE, and WeCom are scaffolded against the same interface; the remaining
listed channels are tracked as follow-ups.

### Design

**Backend**
- New `chat_channel` table (`tenant_id`, `name`, `channel`, `config`
JSON holding `{credential: {...}}`, `dialog_id`, `status`) +
`ChatChannelService` and RESTful CRUD under `/api/v1/chat_channels`.
- Channel framework under `api/channels/`: a `core` registry +
per-channel packages that self-register a builder and implement a common
`Channel` interface (`start`/`stop`/`send` + inbound normalization) over
`IncomingMessage`/`OutgoingMessage`.
- Embedded **reconcile loop** in `ragflow_server`
(`api/channels/bootstrap.py`): loads enabled bots, and
starts/stops/restarts them as rows change (no server restart needed).
Inbound messages run the connected dialog via the non-streaming
completion path, keeping per-end-user conversation history.
- Missing optional channel SDKs degrade gracefully (channel skipped with
a warning; others unaffected). Channel-level errors are logged, not
crashed.
- Feishu's WebSocket client runs in a dedicated thread with its own
event loop to avoid cross-loop/contextvars conflicts with the channel
runtime.

**Frontend**
- **Settings → Chat channels** panel: available-channels grid +
configured-bots list with add/edit/delete and a **Connect assistant**
popup that binds a bot to a dialog.
- Brand icons via simple-icons / reused shared data-source assets, with
colored fallbacks for brands not available.
- Route, sidebar entry, i18n (en/zh), and a top-nav segment-boundary fix
so the settings page no longer highlights the Chat tab.

### Type of change

- [x] New Feature (non-breaking change which adds functionality)

### Notes
- DB: new `chat_channel` table is auto-created; `chat_channel.dialog_id`
is also covered by a `migrate_db` `alter_db_add_column` for existing
installs.
- Channel SDKs (`lark-oapi`, `discord.py`, `python-telegram-bot`,
`line-bot-sdk`, `wechatpy`, `aiohttp`) added to dependencies.
- Screenshots / per-channel credential docs to follow.

<img width="1338" height="1290" alt="Image"
src="https://github.com/user-attachments/assets/042cb2f9-0dad-4e6a-bcf7-43ced4bbd704"
/>

<img width="1344" height="738" alt="Image"
src="https://github.com/user-attachments/assets/373cd08e-ec40-4c67-9c51-4d948b1ba617"
/>

<img width="672" height="887" alt="Image"
src="https://github.com/user-attachments/assets/5a34953f-a9a3-4c1e-869e-5eff0dc64c84"
/>

---------

api/apps/restful_apis/chat_channel_api.py

@@ -0,0 +1,118 @@
+#
+#  Copyright 2024 The InfiniFlow Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+import logging
+
+from api.apps import current_user, login_required
+from api.db.services.chat_channel_service import ChatChannelService
+from api.db.services.dialog_service import DialogService
+from api.utils.api_utils import get_data_error_result, get_json_result, get_request_json, validate_request
+from common.constants import RetCode
+from common.misc_utils import get_uuid
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _chat_channel_auth_error(channel_id: str, user_id: str):
+    """Return the chat channel authorization failure response and log the denial."""
+    LOGGER.warning("chat channel access denied: channel_id=%s user_id=%s", channel_id, user_id)
+    return get_json_result(data=False, message="No authorization.", code=RetCode.AUTHENTICATION_ERROR)
+
+
+@manager.route("/chat_channels", methods=["POST"])  # noqa: F821
+@login_required
+@validate_request("name", "channel", "config")
+async def create_chat_channel():
+    """Create a chat channel bot owned by the current tenant."""
+    req = await get_request_json()
+    channel = {
+        "id": get_uuid(),
+        "tenant_id": current_user.id,
+        "name": req["name"],
+        "channel": req["channel"],
+        "config": req["config"],
+        "dialog_id": req.get("dialog_id") or None,
+        "status": "1",
+    }
+    ChatChannelService.insert(**channel)
+
+    e, conn = ChatChannelService.get_by_id(channel["id"])
+    if not e:
+        return get_data_error_result(message="Failed to create chat channel!")
+    return get_json_result(data=conn.to_dict())
+
+
+@manager.route("/chat_channels", methods=["GET"])  # noqa: F821
+@login_required
+def list_chat_channel():
+    """List chat channel bots owned by the current tenant."""
+    return get_json_result(data=ChatChannelService.list(current_user.id))
+
+
+@manager.route("/chat_channels/<channel_id>", methods=["GET"])  # noqa: F821
+@login_required
+def get_chat_channel(channel_id):
+    """Return a chat channel bot's details when the current user can access it."""
+    if not ChatChannelService.accessible(channel_id, current_user.id):
+        return _chat_channel_auth_error(channel_id, current_user.id)
+
+    e, conn = ChatChannelService.get_by_id(channel_id)
+    if not e:
+        return get_data_error_result(message="Can't find this chat channel!")
+    return get_json_result(data=conn.to_dict())
+
+
+@manager.route("/chat_channels/<channel_id>", methods=["PATCH"])  # noqa: F821
+@login_required
+async def update_chat_channel(channel_id):
+    """Update an accessible chat channel bot's name/config/status."""
+    if not ChatChannelService.accessible(channel_id, current_user.id):
+        return _chat_channel_auth_error(channel_id, current_user.id)
+
+    e, conn = ChatChannelService.get_by_id(channel_id)
+    if not e:
+        return get_data_error_result(message="Can't find this chat channel!")
+
+    req = await get_request_json()
+    if isinstance(req, dict) and isinstance(req.get("data"), dict):
+        req = req["data"]
+
+    # Validate the connected dialog (if provided) belongs to the channel's tenant.
+    if req.get("dialog_id"):
+        e, dia = DialogService.get_by_id(req["dialog_id"])
+        if not e:
+            return get_data_error_result(message="Can't find this chat assistant!")
+        if dia.tenant_id != conn.tenant_id:
+            return _chat_channel_auth_error(channel_id, current_user.id)
+
+    update_fields = {fld: req[fld] for fld in ["name", "config", "dialog_id", "status"] if fld in req}
+    if update_fields:
+        ChatChannelService.update_by_id(channel_id, update_fields)
+
+    e, conn = ChatChannelService.get_by_id(channel_id)
+    if not e:
+        return get_data_error_result(message="Can't find this chat channel!")
+    return get_json_result(data=conn.to_dict())
+
+
+@manager.route("/chat_channels/<channel_id>", methods=["DELETE"])  # noqa: F821
+@login_required
+def rm_chat_channel(channel_id):
+    """Delete an accessible chat channel bot."""
+    if not ChatChannelService.accessible(channel_id, current_user.id):
+        return _chat_channel_auth_error(channel_id, current_user.id)
+
+    ChatChannelService.delete_by_id(channel_id)
+    return get_json_result(data=True)