feishu-bot-cli-antigravity 0.1.0__tar.gz

feishu_bot_cli_antigravity-0.1.0/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.3
+Name: feishu-bot-cli-antigravity
+Version: 0.1.0
+Summary: 一个使用Antigravity SDK驱动的飞书AI助手机器人工具
+Author: Martin
+Author-email: Martin <qule520@126.com>
+Requires-Dist: google-antigravity>=0.1.16
+Requires-Dist: lark-channel-sdk>=1.4.0
+Requires-Dist: lark-oapi>=1.7.3
+Requires-Dist: python-dotenv>=1.2.3
+Requires-Dist: pyyaml>=6.0.3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Feishu Bot Cli Antigravity
+
+基于 Google Antigravity SDK 和飞书开放平台构建的私人 AI 助手机器人命令行工具。
+
+## 架构
+
+```mermaid
+flowchart LR
+    A[用户] -->|飞书消息 / 附件| B[飞书长连接网关]
+    B -->|下载文件至内存| C[Antigravity SDK / Agent]
+    C -->|流式思考与生成| B
+    B -->|CardKit / 消息回复| A
+```
+
+## 功能特点
+
+- **服务监听模式 (`listen`)**：
+  - 基于长连接 (WebSocket) 监听飞书群聊与私聊消息。
+  - 自动将接收到的图片、代码、PDF、文本等多媒体附件**直接下载至内存**，以原生多模态对象传递给 Agent。
+  - 支持会话级消息排队锁 (`asyncio.Lock`) 与 `AsyncExitStack` 上下文生命周期管理。
+  - 支持 CardKit 流式打字机卡片回复与普通消息兜底。
+  - 支持可选的 `--chat-id` 过滤，仅服务指定会话。
+- **命令行模式 (`send`)**：
+  - 命令行主动向指定会话发送消息或文件。
+  - `--chat-id` 为**必须参数**。
+  - 支持发送文本、Markdown 格式消息或本地文件/图片。
+
+## 环境配置
+
+在项目根目录下配置 `.env` 文件：
+
+```env
+LARK_APP_ID=cli_xxxxxxxxxxxxxx
+LARK_APP_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+GEMINI_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+LOG_LEVEL=INFO
+```
+
+## 命令行使用
+
+### 1. 监听服务
+
+启动长连接监听消息并自动调用 Agent 回复：
+
+```bash
+# 监听所有会话
+uv run feishu-bot listen
+
+# 仅监听并响应指定 chat_id 的消息
+uv run feishu-bot listen --chat-id <oc_xxxxxxxxxxxx>
+```
+
+### 2. 主动发送消息
+
+命令行主动向指定会话发送消息：
+
+```bash
+# 发送 Markdown 消息（--chat-id 为必填项）
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --message "**你好！** 这是一条来自 CLI 的消息"
+
+# 发送纯文本消息
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> -m "纯文本消息" --type text
+
+# 发送本地文件或图片（支持同时指定多个文件及附带文本说明）
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --file "./report.pdf" "./chart.png" -m "请查收本期分析报告"
+
+# 从标准输入读取长文本/大段 Markdown（管道传输）
+cat report.md | uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --stdin
+# 或使用 -m -
+cat report.md | uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> -m -
+
+# 交互式终端输入长文本（按 Ctrl+Z 回车或 Ctrl+D 结束输入）
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --stdin
+```
+
+## 测试与代码检查
+
+```bash
+# 运行测试
+uv run pytest
+
+# 运行代码规范检查
+uv run ruff check
+```

feishu_bot_cli_antigravity-0.1.0/README.md

@@ -0,0 +1,84 @@
+# Feishu Bot Cli Antigravity
+
+基于 Google Antigravity SDK 和飞书开放平台构建的私人 AI 助手机器人命令行工具。
+
+## 架构
+
+```mermaid
+flowchart LR
+    A[用户] -->|飞书消息 / 附件| B[飞书长连接网关]
+    B -->|下载文件至内存| C[Antigravity SDK / Agent]
+    C -->|流式思考与生成| B
+    B -->|CardKit / 消息回复| A
+```
+
+## 功能特点
+
+- **服务监听模式 (`listen`)**：
+  - 基于长连接 (WebSocket) 监听飞书群聊与私聊消息。
+  - 自动将接收到的图片、代码、PDF、文本等多媒体附件**直接下载至内存**，以原生多模态对象传递给 Agent。
+  - 支持会话级消息排队锁 (`asyncio.Lock`) 与 `AsyncExitStack` 上下文生命周期管理。
+  - 支持 CardKit 流式打字机卡片回复与普通消息兜底。
+  - 支持可选的 `--chat-id` 过滤，仅服务指定会话。
+- **命令行模式 (`send`)**：
+  - 命令行主动向指定会话发送消息或文件。
+  - `--chat-id` 为**必须参数**。
+  - 支持发送文本、Markdown 格式消息或本地文件/图片。
+
+## 环境配置
+
+在项目根目录下配置 `.env` 文件：
+
+```env
+LARK_APP_ID=cli_xxxxxxxxxxxxxx
+LARK_APP_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+GEMINI_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+LOG_LEVEL=INFO
+```
+
+## 命令行使用
+
+### 1. 监听服务
+
+启动长连接监听消息并自动调用 Agent 回复：
+
+```bash
+# 监听所有会话
+uv run feishu-bot listen
+
+# 仅监听并响应指定 chat_id 的消息
+uv run feishu-bot listen --chat-id <oc_xxxxxxxxxxxx>
+```
+
+### 2. 主动发送消息
+
+命令行主动向指定会话发送消息：
+
+```bash
+# 发送 Markdown 消息（--chat-id 为必填项）
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --message "**你好！** 这是一条来自 CLI 的消息"
+
+# 发送纯文本消息
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> -m "纯文本消息" --type text
+
+# 发送本地文件或图片（支持同时指定多个文件及附带文本说明）
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --file "./report.pdf" "./chart.png" -m "请查收本期分析报告"
+
+# 从标准输入读取长文本/大段 Markdown（管道传输）
+cat report.md | uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --stdin
+# 或使用 -m -
+cat report.md | uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> -m -
+
+# 交互式终端输入长文本（按 Ctrl+Z 回车或 Ctrl+D 结束输入）
+uv run feishu-bot send --chat-id <oc_xxxxxxxxxxxx> --stdin
+```
+
+## 测试与代码检查
+
+```bash
+# 运行测试
+uv run pytest
+
+# 运行代码规范检查
+uv run ruff check
+```

feishu_bot_cli_antigravity-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[project]
+name = "feishu-bot-cli-antigravity"
+version = "0.1.0"
+description = "一个使用Antigravity SDK驱动的飞书AI助手机器人工具"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "google-antigravity>=0.1.16",
+    "lark-channel-sdk>=1.4.0",
+    "lark-oapi>=1.7.3",
+    "python-dotenv>=1.2.3",
+    "pyyaml>=6.0.3",
+]
+
+[[project.authors]]
+name = "Martin"
+email = "qule520@126.com"
+
+[project.scripts]
+feishu-bot-cli-antigravity = "feishu_bot_cli_antigravity.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "ruff>=0.16.6",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+src = [
+    "src",
+    "tests",
+]
+exclude = [
+    ".agents",
+    ".venv",
+]
+
+[tool.ruff.lint]
+ignore = [
+    "BLE001",
+    "ASYNC230",
+    "G201",
+]

feishu_bot_cli_antigravity-0.1.0/pyproject.toml.orig

@@ -0,0 +1,34 @@
+[project]
+name = "feishu-bot-cli-antigravity"
+version = "0.1.0"
+description = "一个使用Antigravity SDK驱动的飞书AI助手机器人工具"
+readme = "README.md"
+authors = [{ name = "Martin", email = "qule520@126.com" }]
+requires-python = ">=3.13"
+dependencies = [
+    "google-antigravity>=0.1.16",
+    "lark-channel-sdk>=1.4.0",
+    "lark-oapi>=1.7.3",
+    "python-dotenv>=1.2.3",
+    "pyyaml>=6.0.3",
+]
+
+[project.scripts]
+feishu-bot-cli-antigravity = "feishu_bot_cli_antigravity.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.7,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = ["pytest>=9.1.1", "pytest-asyncio>=1.4.0", "ruff>=0.16.6"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.ruff]
+src = ["src", "tests"]
+exclude = [".agents", ".venv"]
+
+[tool.ruff.lint]
+ignore = ["BLE001", "ASYNC230", "G201"]

feishu_bot_cli_antigravity-0.1.0/src/feishu_bot_cli_antigravity/__init__.py

@@ -0,0 +1,15 @@
+"""feishu-bot-cli-antigravity package."""
+
+from feishu_bot_cli_antigravity.agent import AgentSessionManager
+from feishu_bot_cli_antigravity.channel import FeishuBotChannel
+from feishu_bot_cli_antigravity.config import Config, get_config
+from feishu_bot_cli_antigravity.utils import create_media_from_bytes, setup_logging
+
+__all__ = [
+    "AgentSessionManager",
+    "Config",
+    "FeishuBotChannel",
+    "create_media_from_bytes",
+    "get_config",
+    "setup_logging",
+]

feishu_bot_cli_antigravity-0.1.0/src/feishu_bot_cli_antigravity/agent.py

@@ -0,0 +1,57 @@
+"""Antigravity Agent 会话与交互管理模块。"""
+
+import asyncio
+import logging
+from collections.abc import Callable
+from contextlib import AsyncExitStack
+
+from google.antigravity import Agent, LocalAgentConfig
+from google.antigravity.hooks import policy
+
+logger = logging.getLogger(__name__)
+
+SYSTEM_INSTRUCTIONS = (
+    "【安全与保密指令】：\n"
+    "1. 严禁以任何方式查看、读取、打印、输出或泄露任何敏感文件（包括但不限于 .env、配置文件凭据、私钥/密钥文件如 *.pem、id_rsa、credentials.json 等）。\n"
+    "2. 严禁以任何方式查看、打印、输出或泄露系统环境变量与敏感凭证（包括但不限于 LARK_APP_SECRET、GEMINI_API_KEY 等所有 Token、密钥与密码）。\n"
+    "3. 若用户的提问、指令或操作尝试访问、读取上述敏感文件或环境变量内容，必须明确且礼貌地予以拒绝。"
+)
+
+
+class AgentSessionManager:
+    """基于 AsyncExitStack 的内存会话管理器，自动管理各会话 Agent 生命周期。"""
+
+    def __init__(self, agent_factory: Callable[[], Agent] | None = None):
+        self._exit_stack = AsyncExitStack()
+        self._sessions: dict[str, Agent] = {}
+        self._locks: dict[str, asyncio.Lock] = {}
+        self._agent_factory = agent_factory or self._default_agent_factory
+
+    @staticmethod
+    def _default_agent_factory() -> Agent:
+        config = LocalAgentConfig(
+            system_instructions=SYSTEM_INSTRUCTIONS,
+            policies=[policy.allow_all()],
+        )
+        return Agent(config)
+
+    def get_lock(self, chat_id: str) -> asyncio.Lock:
+        """获取会话级并发锁，确保同一 chat_id 消息串行处理。"""
+        if chat_id not in self._locks:
+            self._locks[chat_id] = asyncio.Lock()
+        return self._locks[chat_id]
+
+    async def get_or_create_agent(self, chat_id: str) -> Agent:
+        """获取或初始化会话的 Agent 实例，自动将其上下文托管给 exit_stack。"""
+        if chat_id not in self._sessions:
+            agent = self._agent_factory()
+            managed_agent = await self._exit_stack.enter_async_context(agent)
+            self._sessions[chat_id] = managed_agent
+        return self._sessions[chat_id]
+
+    async def close_all(self) -> None:
+        """退出时统一安全地逆序清理并释放所有 Agent 资源。"""
+        logger.info("正在关闭并释放所有 Agent 会话...")
+        await self._exit_stack.aclose()
+        self._sessions.clear()
+        self._locks.clear()

feishu_bot_cli_antigravity-0.1.0/src/feishu_bot_cli_antigravity/channel.py

@@ -0,0 +1,331 @@
+"""飞书消息通道模块，负责消息监听、多模态附件下载及主动消息发送。"""
+
+import asyncio
+import logging
+import os
+from typing import Any
+
+import yaml
+from lark_channel import (
+    Events,
+    FeishuChannel,
+    FileContent,
+    ImageContent,
+    InboundMessage,
+)
+from lark_channel.core import LogLevel
+
+from .agent import AgentSessionManager
+from .config import Config
+from .utils import create_media_from_bytes, format_iso_time
+
+logger = logging.getLogger(__name__)
+
+
+class FeishuBotChannel:
+    """飞书机器人通道管理类。"""
+
+    def __init__(
+        self,
+        config: Config,
+        filter_chat_id: str | None = None,
+        session_manager: AgentSessionManager | None = None,
+        channel: FeishuChannel | None = None,
+    ):
+        self.config = config
+        self.config.validate()
+
+        self.filter_chat_id = filter_chat_id.strip() if filter_chat_id else None
+        self.session_manager = session_manager or AgentSessionManager()
+
+        if channel:
+            self.channel = channel
+        else:
+            log_level_map = {
+                "DEBUG": LogLevel.DEBUG,
+                "INFO": LogLevel.INFO,
+                "WARNING": LogLevel.WARNING,
+                "ERROR": LogLevel.ERROR,
+            }
+            sdk_log_level = log_level_map.get(
+                self.config.log_level.upper(), LogLevel.INFO
+            )
+            self.channel = FeishuChannel(
+                app_id=self.config.lark_app_id,
+                app_secret=self.config.lark_app_secret,
+                domain=self.config.lark_domain,
+                log_level=sdk_log_level,
+            )
+
+    async def _download_inbound_files(self, msg: InboundMessage) -> list[Any]:
+        """将消息中的所有文件/多媒体资源下载至内存，并转换为 Antigravity 多模态对象。"""
+        media_items: list[Any] = []
+        msg_id = msg.id
+
+        # 1. 优先遍历 resources 列表
+        resources = msg.resources or []
+        for res in resources:
+            try:
+                data = await self.channel.download_resource(
+                    file_key=res.file_key,
+                    resource_type=res.type,
+                    message_id=msg_id,
+                )
+                if data:
+                    media_obj = create_media_from_bytes(
+                        data=data,
+                        file_name=res.file_name,
+                        resource_type=res.type,
+                    )
+                    media_items.append(media_obj)
+                    logger.info(
+                        "成功下载附件到内存 | chat_id: %s | 类型: %s | 文件名: %s | 大小: %d 字节",
+                        msg.chat_id,
+                        res.type,
+                        res.file_name or "未指定",
+                        len(data),
+                    )
+                else:
+                    logger.warning(
+                        "下载附件失败 (返回空数据) | file_key: %s", res.file_key
+                    )
+            except Exception as e:
+                logger.error("下载附件异常 | file_key: %s: %s", res.file_key, e)
+
+        # 2. 如果 resources 未解析出资源，兜底检查 content 结构
+        if not media_items:
+            content = msg.content
+            if isinstance(content, FileContent) and getattr(content, "file_key", None):
+                try:
+                    data = await self.channel.download_resource(
+                        file_key=content.file_key,
+                        resource_type="file",
+                        message_id=msg_id,
+                    )
+                    if data:
+                        media_items.append(
+                            create_media_from_bytes(
+                                data, content.file_name, "file"
+                            )
+                        )
+                except Exception as e:
+                    logger.error("兜底下载 FileContent 异常: %s", e)
+            elif isinstance(content, ImageContent) and getattr(content, "image_key", None):
+                try:
+                    data = await self.channel.download_resource(
+                        file_key=content.image_key,
+                        resource_type="image",
+                        message_id=msg_id,
+                    )
+                    if data:
+                        media_items.append(
+                            create_media_from_bytes(data, None, "image")
+                        )
+                except Exception as e:
+                    logger.error("兜底下载 ImageContent 异常: %s", e)
+
+        return media_items
+
+    async def on_message(self, msg: InboundMessage) -> None:
+        """处理飞书收到的消息。"""
+        # 忽略机器人自身发送的消息，防止消息回环死循环
+        if msg.sender_is_bot:
+            return
+
+        chat_id = msg.chat_id
+        msg_id = msg.id
+
+        # 如果配置了 filter_chat_id，则仅响应该指定的会话
+        if self.filter_chat_id and chat_id != self.filter_chat_id:
+            logger.debug(
+                "跳过非目标会话消息 | 当前 chat_id: %s | 目标 chat_id: %s",
+                chat_id,
+                self.filter_chat_id,
+            )
+            return
+
+        # 消息元数据
+        message_metadata = {
+            "from": "feishu",
+            "chat_id": chat_id,
+            "sender_id": msg.sender_id,
+            "message_id": msg_id,
+            "create_time": format_iso_time(msg.create_time),
+            "chat_type": msg.chat_type,
+        }
+
+        # 提取用户文本
+        prompt = (msg.content_text or "").strip()
+
+        # 下载附件到内存中
+        media_items = await self._download_inbound_files(msg)
+
+        if not prompt and not media_items:
+            logger.info("收到来自 %s 的空消息且无可用附件，跳过处理", msg.sender_id)
+            return
+
+        logger.info(
+            "收到消息 | chat_id: %s | sender_id: %s | content_text: %s | media_items: %d",
+            chat_id,
+            msg.sender_name or msg.sender_id,
+            prompt or "[无文本]",
+            len(media_items),
+        )
+
+        # 组装给 Agent 的输入
+        agent_input = [
+            "---\n"
+            + yaml.safe_dump(message_metadata, allow_unicode=True, sort_keys=False)
+            + "---\n"
+        ]
+        if prompt:
+            agent_input.append(prompt)
+        if media_items:
+            agent_input.extend(media_items)
+
+        lock = self.session_manager.get_lock(chat_id)
+
+        async with lock:
+            typing_reaction_id = None
+            try:
+                # 提示用户 Agent 正在思考中
+                if msg_id:
+                    typing_reaction_id = await self.channel.add_typing_reaction(msg_id)
+
+                # 获取常驻 Agent 并生成回复
+                agent = await self.session_manager.get_or_create_agent(chat_id)
+                response = await agent.chat(agent_input)
+
+                tokens = []
+                stream_succeeded = False
+
+                # 尝试 CardKit 流式打字机卡片输出
+                try:
+                    async def producer(stream):
+                        async for token in response:
+                            tokens.append(token)
+                            await stream.append(token)
+
+                    await self.channel.stream(chat_id, {"markdown": producer})
+                    stream_succeeded = True
+                except Exception as stream_err:
+                    logger.warning(
+                        "流式输出未生效 (%s)，自动降级为标准消息发送。"
+                        "提示：如需打字机卡片流式输出，请在飞书开放平台申请 [cardkit:card:write] 权限。",
+                        stream_err,
+                    )
+
+                # 降级发送完整消息
+                if not stream_succeeded:
+                    async for token in response:
+                        tokens.append(token)
+                    full_reply = "".join(tokens)
+                    if not full_reply and hasattr(response, "text"):
+                        full_reply = await response.text()
+
+                    if full_reply:
+                        try:
+                            await self.channel.send(chat_id, {"markdown": full_reply})
+                        except Exception:
+                            await self.channel.send(chat_id, {"text": full_reply})
+
+                logger.info("回复完成 | chat_id: %s", chat_id)
+
+            except Exception as e:
+                logger.error("Agent 处理出错: %s", e, exc_info=True)
+                try:
+                    await self.channel.send(
+                        chat_id, {"text": f"抱歉，处理您的请求时出现异常: {e}"}
+                    )
+                except Exception as send_err:
+                    logger.error("发送错误提示失败: %s", send_err)
+            finally:
+                if typing_reaction_id and msg_id:
+                    await self.channel.remove_typing_reaction(
+                        msg_id, typing_reaction_id
+                    )
+
+    async def start_listening(self) -> None:
+        """启动飞书长连接监听服务。"""
+        self.channel.on(Events.MESSAGE, self.on_message)
+
+        try:
+            filter_hint = f" (过滤会话: {self.filter_chat_id})" if self.filter_chat_id else ""
+            logger.info("飞书机器人服务启动中，正在连接长连接网关%s...", filter_hint)
+            await self.channel.connect()
+        except (asyncio.CancelledError, KeyboardInterrupt):
+            pass
+        finally:
+            await self.close()
+
+    async def close(self) -> None:
+        """关闭通道与释放所有资源。"""
+        self.channel.stop()
+        await self.session_manager.close_all()
+        logger.info("飞书机器人已安全断开并退出。")
+
+    async def send_message(
+        self,
+        chat_id: str,
+        message: str | None = None,
+        file_paths: list[str] | str | None = None,
+        message_type: str = "markdown",
+    ) -> Any:
+        """主动向飞书会话发送消息或多个文件 (支持文件与文本组合发送)。"""
+        results = []
+
+        # 归一化为文件路径列表
+        paths: list[str] = []
+        if file_paths:
+            if isinstance(file_paths, str):
+                paths.append(file_paths)
+            else:
+                paths.extend(file_paths)
+
+        for fp in paths:
+            if not os.path.exists(fp):
+                raise FileNotFoundError(f"未找到待发送的文件: {fp}")
+
+            with open(fp, "rb") as f:
+                file_bytes = f.read()
+
+            file_name = os.path.basename(fp)
+            dot_index = file_name.rfind(".")
+            ext = file_name[dot_index:].lower() if dot_index != -1 else ""
+
+            # 判断是否为图片
+            if ext in {".png", ".jpg", ".jpeg", ".webp", ".bmp", ".gif"}:
+                # 仅在仅发送单张图片且附带 message 时，合并为图文消息
+                if len(paths) == 1 and message:
+                    logger.info("正在向 %s 发送带说明的图片文件: %s", chat_id, file_name)
+                    res = await self.channel.send(
+                        chat_id,
+                        {"image": {"source": file_bytes}, "caption": message},
+                    )
+                    results.append(res)
+                    message = None  # 图片已带 caption，无需重复发送单独的文本
+                else:
+                    logger.info("正在向 %s 发送图片文件: %s", chat_id, file_name)
+                    res = await self.channel.send(
+                        chat_id,
+                        {"image": {"source": file_bytes}},
+                    )
+                    results.append(res)
+            else:
+                logger.info("正在向 %s 发送附件文件: %s", chat_id, file_name)
+                res = await self.channel.send(
+                    chat_id,
+                    {"file": {"source": file_bytes, "file_name": file_name}},
+                )
+                results.append(res)
+
+        # 发送附带的文本/Markdown 消息
+        if message:
+            logger.info("正在向 %s 发送消息: %s", chat_id, message)
+            if message_type == "text":
+                res = await self.channel.send(chat_id, {"text": message})
+            else:
+                res = await self.channel.send(chat_id, {"markdown": message})
+            results.append(res)
+
+        return results[0] if len(results) == 1 else results

feishu_bot_cli_antigravity-0.1.0/src/feishu_bot_cli_antigravity/cli.py

@@ -0,0 +1,224 @@
+import argparse
+import asyncio
+import contextlib
+import sys
+
+from .channel import FeishuBotChannel
+from .config import Config
+from .utils import setup_logging
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """构建 CLI 参数解析器。"""
+    parser = argparse.ArgumentParser(
+        description="基于 Antigravity SDK 的飞书私人 AI 助手工具",
+    )
+    parser.add_argument(
+        "--log-level",
+        default=None,
+        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
+        help="日志输出级别 (覆盖环境变量 LOG_LEVEL，默认: INFO)",
+    )
+
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+        help="支持的子命令",
+    )
+
+    # 1. 监听消息子命令 (listen)
+    listen_parser = subparsers.add_parser(
+        "listen",
+        aliases=["serve"],
+        help="启动长连接网关监听飞书消息并调用 Agent 回复",
+    )
+    listen_parser.add_argument(
+        "--chat-id",
+        "-c",
+        dest="chat_id",
+        default=None,
+        help="可选。若指定则仅响应该 chat_id 的消息，未指定则响应所有群/单聊",
+    )
+
+    # 2. 命令行主动发送消息子命令 (send)
+    send_parser = subparsers.add_parser(
+        "send",
+        help="主动向指定飞书会话发送消息或文件",
+    )
+    send_parser.add_argument(
+        "--chat-id",
+        "-c",
+        dest="chat_id",
+        required=True,
+        help="必填。目标飞书会话 ID (chat_id)",
+    )
+    msg_group = send_parser.add_mutually_exclusive_group()
+    msg_group.add_argument(
+        "--message",
+        "-m",
+        dest="message",
+        default=None,
+        help="要发送的消息内容 (支持 Markdown)。若指定为 '-' 则从标准输入读取",
+    )
+    msg_group.add_argument(
+        "--stdin",
+        "-s",
+        dest="read_stdin",
+        action="store_true",
+        help="从标准输入 (stdin) 读取消息内容",
+    )
+    send_parser.add_argument(
+        "--file",
+        "-f",
+        dest="file_paths",
+        nargs="+",
+        default=None,
+        help="要发送的本地文件路径 (支持同时指定多个文件)",
+    )
+    send_parser.add_argument(
+        "--type",
+        "-t",
+        dest="message_type",
+        choices=["markdown", "text"],
+        default="markdown",
+        help="消息类型: markdown (默认) 或 text",
+    )
+
+    return parser
+
+
+def read_stdin_content() -> str:
+    """从标准输入读取消息内容，强制使用 UTF-8 编码解码以避免 Windows 默认编码（如 CP936/GBK）导致的乱码。"""
+    if hasattr(sys.stdin, "buffer"):
+        with contextlib.suppress(AttributeError, ValueError):
+            raw_bytes = sys.stdin.buffer.read()
+            try:
+                return raw_bytes.decode("utf-8-sig")
+            except UnicodeDecodeError:
+                return raw_bytes.decode(errors="replace")
+
+    if hasattr(sys.stdin, "reconfigure"):
+        with contextlib.suppress(Exception):
+            sys.stdin.reconfigure(encoding="utf-8")
+
+    return sys.stdin.read()
+
+
+def resolve_send_message(args: argparse.Namespace) -> str | None:
+    """从命令行参数或标准输入中解析待发送的消息内容。"""
+    is_stdin_requested = getattr(args, "read_stdin", False) or args.message == "-"
+
+    if is_stdin_requested:
+        if sys.stdin.isatty():
+            eof_hint = "Ctrl+Z 回车" if sys.platform == "win32" else "Ctrl+D"
+            print(
+                f"[INFO] 正在从标准输入读取消息内容 (按 {eof_hint} 结束输入)...",
+                file=sys.stderr,
+            )
+        content = read_stdin_content()
+        if not content.strip() and not args.file_paths:
+            raise ValueError("从标准输入读取到的内容为空。")
+        return content
+
+    if args.message is not None:
+        return args.message
+
+    # 当未显式指定 --message / --stdin 且未指定 --file 时，若检测到管道/重定向输入，则自动读取 stdin
+    if not args.file_paths and not sys.stdin.isatty():
+        content = read_stdin_content()
+        return content if content.strip() else None
+
+    return None
+
+
+async def run_listen(chat_id: str | None, config: Config) -> None:
+    """运行监听服务。"""
+    channel = FeishuBotChannel(config=config, filter_chat_id=chat_id)
+    await channel.start_listening()
+
+
+async def run_send(
+    chat_id: str,
+    message: str | None,
+    file_paths: list[str] | None,
+    message_type: str,
+    config: Config,
+) -> None:
+    """运行主动发送消息。"""
+    if message == "-":
+        if sys.stdin.isatty():
+            eof_hint = "Ctrl+Z 回车" if sys.platform == "win32" else "Ctrl+D"
+            print(
+                f"[INFO] 正在从标准输入读取消息内容 (按 {eof_hint} 结束输入)...",
+                file=sys.stderr,
+            )
+        content = read_stdin_content()
+        if not content.strip() and not file_paths:
+            raise ValueError("从标准输入读取到的内容为空。")
+        message = content
+
+    if not message and not file_paths:
+        raise ValueError("主动发送消息必须提供 --message、--stdin 或 --file 至少一项参数。")
+
+    channel = FeishuBotChannel(config=config)
+    try:
+        res = await channel.send_message(
+            chat_id=chat_id,
+            message=message,
+            file_paths=file_paths,
+            message_type=message_type,
+        )
+        print(f"[SUCCESS] 消息发送成功: {res}")
+    finally:
+        await channel.close()
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI 主入口函数。"""
+    if hasattr(sys.stdout, "reconfigure"):
+        with contextlib.suppress(Exception):
+            sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    if hasattr(sys.stderr, "reconfigure"):
+        with contextlib.suppress(Exception):
+            sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    config = Config.from_env()
+    if args.log_level:
+        config.log_level = args.log_level
+
+    setup_logging(config.log_level)
+
+    try:
+        config.validate()
+    except ValueError as e:
+        print(f"[ERROR] 配置错误: {e}", file=sys.stderr)
+        return 1
+
+    try:
+        if args.command in ("listen", "serve"):
+            asyncio.run(run_listen(args.chat_id, config))
+        elif args.command == "send":
+            message = resolve_send_message(args)
+            asyncio.run(
+                run_send(
+                    chat_id=args.chat_id,
+                    message=message,
+                    file_paths=args.file_paths,
+                    message_type=args.message_type,
+                    config=config,
+                )
+            )
+        return 0
+    except KeyboardInterrupt:
+        print("\n[INFO] 用户中断，程序已退出。")
+        return 0
+    except Exception as e:
+        print(f"[ERROR] 执行失败: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

feishu_bot_cli_antigravity-0.1.0/src/feishu_bot_cli_antigravity/config.py

@@ -0,0 +1,41 @@
+"""配置管理模块。"""
+
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+
+# 加载 .env 环境变量
+load_dotenv(override=True)
+
+
+@dataclass
+class Config:
+    """机器人与服务配置项。"""
+
+    lark_app_id: str = ""
+    lark_app_secret: str = ""
+    lark_domain: str | None = None
+    log_level: str = "INFO"
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        """从环境变量读取配置。"""
+        return cls(
+            lark_app_id=os.getenv("LARK_APP_ID", "").strip(),
+            lark_app_secret=os.getenv("LARK_APP_SECRET", "").strip(),
+            lark_domain=os.getenv("LARK_DOMAIN"),
+            log_level=os.getenv("LOG_LEVEL", "INFO").strip(),
+        )
+
+    def validate(self) -> None:
+        """校验关键凭据是否已配置。"""
+        if not self.lark_app_id or not self.lark_app_secret:
+            raise ValueError(
+                "请在环境变量或 .env 文件中配置 LARK_APP_ID 与 LARK_APP_SECRET"
+            )
+
+
+def get_config() -> Config:
+    """获取配置实例。"""
+    return Config.from_env()

feishu_bot_cli_antigravity-0.1.0/src/feishu_bot_cli_antigravity/utils.py

@@ -0,0 +1,117 @@
+"""工具类模块，提供日志配置与内存文件解析功能。"""
+
+import logging
+import mimetypes
+from datetime import datetime
+
+from google.antigravity import types
+
+
+def format_iso_time(timestamp: float | str | None) -> str:
+    """将时间戳（毫秒或秒）转换为带当前时区的 ISO 8601 标准时间字符串。"""
+    if timestamp is None or timestamp == "":
+        return ""
+    try:
+        ts = float(timestamp)
+        # 兼容毫秒级时间戳（如 13 位数字，> 10^11）
+        if ts > 1e11:
+            ts /= 1000.0
+        return datetime.fromtimestamp(ts).astimezone().isoformat()
+    except Exception:
+        return str(timestamp)
+
+
+def setup_logging(level: str = "INFO") -> None:
+    """初始化标准 logging 配置。"""
+    numeric_level = getattr(logging, level.upper(), logging.INFO)
+    logging.basicConfig(
+        level=numeric_level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+
+# 常见纯文本/代码文件扩展名
+TEXT_EXTENSIONS = {
+    ".txt", ".md", ".py", ".json", ".csv", ".xml", ".html", ".htm",
+    ".css", ".js", ".ts", ".jsx", ".tsx", ".yaml", ".yml", ".toml",
+    ".ini", ".cfg", ".conf", ".sh", ".bash", ".bat", ".ps1", ".sql",
+    ".env", ".c", ".cpp", ".cc", ".h", ".hpp", ".java", ".rs", ".go",
+    ".php", ".rb", ".log",
+}
+
+
+def guess_mime_type(file_name: str | None, resource_type: str = "file") -> str:
+    """根据文件名与资源类型推断 MIME 类型。"""
+    if file_name:
+        dot_index = file_name.rfind(".")
+        ext = file_name[dot_index:].lower() if dot_index != -1 else ""
+
+        if ext == ".json":
+            return "application/json"
+        if ext == ".csv":
+            return "text/csv"
+        if ext in {".html", ".htm"}:
+            return "text/html"
+        if ext == ".css":
+            return "text/css"
+        if ext == ".js":
+            return "text/javascript"
+        if ext == ".xml":
+            return "text/xml"
+        if ext == ".pdf":
+            return "application/pdf"
+        if ext in TEXT_EXTENSIONS:
+            return "text/plain"
+
+        guessed, _ = mimetypes.guess_type(file_name)
+        if guessed:
+            return guessed
+
+    if resource_type == "image":
+        return "image/png"
+    if resource_type == "audio":
+        return "audio/mp3"
+    if resource_type == "video":
+        return "video/mp4"
+
+    return "application/octet-stream"
+
+
+def create_media_from_bytes(
+    data: bytes,
+    file_name: str | None = None,
+    resource_type: str = "file",
+) -> types.Image | types.Document | types.Audio | types.Video | str:
+    """
+    将内存中的二进制文件字节转换为 Antigravity SDK 原生识别的多模态对象。
+    若属于 Gemini SDK 支持的文件格式，直接构造对应的 Image / Document / Audio / Video；
+    若为纯文本内容但扩展名未知，尝试 UTF-8 解码转为 Document(text/plain)；
+    若完全不支持，则降级为带有文件描述的文本提示。
+    """
+    mime_type = guess_mime_type(file_name, resource_type)
+
+    # 1. 尝试使用 types.from_bytes 构造（自动映射到 Image / Document / Audio / Video）
+    try:
+        return types.from_bytes(data=data, mime_type=mime_type, description=file_name)
+    except ValueError:
+        pass
+
+    # 2. 尝试以 UTF-8 解码为纯文本 Document
+    try:
+        _ = data.decode("utf-8")
+        return types.Document(data=data, mime_type="text/plain", description=file_name)
+    except UnicodeDecodeError:
+        pass
+
+    # 3. Magic Number 兜底识别
+    if data.startswith(b"\x89PNG\r\n\x1a\n"):
+        return types.Image(data=data, mime_type="image/png", description=file_name)
+    if data.startswith(b"\xff\xd8\xff"):
+        return types.Image(data=data, mime_type="image/jpeg", description=file_name)
+    if data.startswith(b"%PDF"):
+        return types.Document(data=data, mime_type="application/pdf", description=file_name)
+
+    # 4. 无法直接解析的二进制文件，降级为文本提示
+    desc = file_name or "未知文件名"
+    return f"[用户上传了附件文件: {desc}，大小: {len(data)} 字节，暂不支持该格式直接解析]"