Content
# Tool List
[](https://www.npmjs.com/package/feishu-mcp)
[](./LICENSE)
Provides access, editing, and structured processing capabilities for Feishu documents for AI-driven coding tools like [Cursor](https://cursor.sh/), [Windsurf](https://codeium.com/windsurf), and [Cline](https://cline.bot/), **and supports Feishu task management and user information query**, based on the [Model Context Protocol](https://modelcontextprotocol.io/introduction) server implementation.
**Now supports the `feishu-tool` standalone CLI tool**, which allows direct invocation of all Feishu tools in the terminal or script without starting the MCP server. Cooperate with [Feishu-Skill](https://github.com/cso1z/Feishu-Skill) to enable AI Agents like Claude Code to automatically choose the most suitable way to operate Feishu.
This project enables AI coding tools to:
- **Document Processing**: Directly obtain, understand, create, and edit Feishu documents, significantly improving document processing intelligence and efficiency.
- **Task Management**: List, create, update, and delete Feishu tasks, support subtasks and member management (require user authentication).
- **User Information**: Search for Feishu users by name or batch obtain by ID, facilitating task assignment and document collaboration (require user authentication).
**Fully covers the real usage process of Feishu documents**, helping you efficiently utilize document resources:
1. **Folder directory acquisition**: Quickly obtain and browse all documents under the Feishu document folder, facilitating overall management and search.
2. **Content acquisition and understanding**: Supports structured, block-based, rich text, and multi-dimensional content reading, allowing AI to accurately understand the document context.
3. **Intelligent creation and editing**: Automatically create new documents, batch generate and edit content, meeting diverse writing needs.
4. **Efficient retrieval and search**: Built-in keyword search, helping you quickly find target information in a large number of documents.
5. **Task management and user query**: Supports Feishu task CRUD and user information search, facilitating task association and personnel in documents.
This project enables intelligent acquisition, editing, and search of Feishu documents, and extends task and user management capabilities, improving content processing efficiency and experience.
### 💡Project Recommendations:
Use Claude Code with [claude-ip-guard](https://github.com/cso1z/claude-ip-guard) - Automatically detect IP geographic location and intercept restricted area access, preventing Claude account blocking due to network changes.
### 🎬 Demo Videos
You can understand the actual usage effects and operation process of MCP through the following videos:
<a href="https://www.bilibili.com/video/BV1z7MdzoEfu/?vd_source=94c14da5a71aeb01f665f159dd3d89c8">
<img src="image/demo.png" alt="Feishu MCP Usage Demo" width="300"/>
</a>
<a href="https://www.bilibili.com/video/BV18z3gzdE1w/?vd_source=94c14da5a71aeb01f665f159dd3d89c8">
<img src="image/demo_1.png" alt="Feishu MCP Usage Demo" width="300"/>
</a>
> ⭐ **Star this project to get the latest features and important updates in time!** Follow the project to ensure you don't miss any new features, fixes, and optimizations, and help you continue to use it efficiently. Your support will also help us improve and develop the project better. ⭐
## 🛠️ Tool Function Details
| Function Category | Tool Name | Description | Use Case | Status |
|---------|--------------------------------------|-------------|--------------------------|-------|
| **Document Management** | `create_feishu_document` | Create a new Feishu document | Create documents from scratch | ✅ Completed |
| | `get_feishu_document_info` | Get document basic information | Verify document existence and permissions | ✅ Completed |
| | `get_feishu_document_blocks` | Get document block structure | Understand document hierarchy | ✅ Completed |
| **Content Editing** | `batch_create_feishu_blocks` | Batch create multiple blocks | Efficiently create continuous content | ✅ Completed |
| | `update_feishu_block_text` | Update block text content | Modify existing content | ✅ Completed |
| | `delete_feishu_document_blocks` | Delete document blocks | Clean and refactor document content | ✅ Completed |
| **Folder Management** | `get_feishu_folder_files` | Get folder file list | Browse folder content | ✅ Completed |
| | `create_feishu_folder` | Create a new folder | Organize document structure | ✅ Completed |
| **Search Function** | `search_feishu_documents` | Search documents | Find specific content | ✅ Completed |
| **Tool Function** | `get_feishu_document_info` | Get wiki document information | Convert Wiki link to document ID, create wiki sub-node | ✅ Completed |
| | `get_feishu_image_resource` | Get image resources | Download images in documents | ✅ Completed |
| | `get_feishu_whiteboard_content` | Get whiteboard content | Get graphical elements and structure (flowcharts, mind maps, etc.) | ✅ Completed |
| **Advanced Function** | `create_feishu_table` | Create and edit tables | Structured data display | ✅ Completed |
| | Flowchart insertion | Support flowcharts and mind maps | Process comb梳理 and visualization | ✅ Completed |
| | Flowchart insertion (whiteboard form) | Support flowcharts and mind maps | Process comb梳理 and visualization | ✅ Completed |
| Image insertion | `upload_and_bind_image_to_block` | Support inserting local and remote images | Modify document content | ✅ Completed |
| | Formula support | Support mathematical formulas | Academic and technical documents | ✅ Completed |
| | | | | |
| **Task Management** | `list_feishu_tasks` | List tasks I am responsible for | View pending/completed tasks | ✅ Completed |
| | `create_feishu_task` | Batch create tasks (including subtasks) | Create new tasks, split subtasks | ✅ Completed |
| | `update_feishu_task` | Update tasks | Modify content, members, reminders | ✅ Completed |
| | `delete_feishu_task` | Batch delete tasks | Clean up tasks | ✅ Completed |
| **User Information** | `get_feishu_users` | Search for users by name or batch obtain by ID | Find members, task assignment | ✅ Completed |
### 🎨 Supported Style Functions (Basic support for all md formats)
- **Text Style**: Bold, Italic, Underline, Strikethrough, Inline code
- **Text Color**: Gray, Brown, Orange, Yellow, Green, Blue, Purple
- **Alignment**: Left alignment, Center, Right alignment
- **Title Level**: Support 1-9 level titles
- **Code Block**: Support multiple programming language syntax highlighting
- **List**: Ordered list (numbered), Unordered list (bullet points)
- **Image**: Support local and network images
- **Formula**: Insert mathematical formulas in text blocks, support LaTeX syntax
- **mermaid Chart**: Support flowcharts, timing diagrams, mind maps, class diagrams, pie charts, etc.
- **Table**: Support creating multi-row list tables, cells can contain text, titles, lists, code blocks, etc.
- **Feishu Document Whiteboard**: Support creating Feishu document whiteboards, providing richer and more diverse content.
---
## 📈 Weekly Plan: Improve Tool Efficiency
- ~~**Simplify Toolset**: 21 tools → 13 tools, remove redundancy, focus on core functions~~ 0.0.15 ✅
- ~~**Optimize Description**: 7000+ tokens → 3000+ tokens, simplify prompts, save request tokens~~ 0.0.15 ✅
- ~~**Batch Enhancement**: Add batch update, batch image upload, single operation efficiency improved by 50%~~ 0.0.15 ✅
- **Process Optimization**: Reduce multi-step calls, achieve one-click completion of complex tasks
- ~~**Support Multiple Credential Types**: Including tenant_access_token and user_access_token, meet authentication needs in different scenarios~~ (Feishu application configuration changes) 0.0.16 ✅。
- ~~**Support cursor user login**: Convenient for cursor platform user authentication Not done, no need ❌~~
- ~~**Support mermaid charts**: Flowcharts, timing diagrams, etc., enrich document content~~ 0.1.11 ✅
- ~~**Support table creation**: Create complex tables with various block types, support style control~~ 0.1.2 ✅
- ~~**Support Feishu multi-user authentication**: One deployment, multiple users can use~~ 0.1.3 ✅
- ~~**Support user_access_token automatic refresh**: No need for frequent authorization, improve usage experience~~ 0.1.6 ✅
- ~~**Support authorization range verification**: Verify application authorization to ensure it meets the requirements of the current tool. If the conditions are not met, provide friendly guidance for users to use smoothly~~ 0.1.7 ✅
- ~~**Support creating whiteboard content**: Compared with Mermaid charts, whiteboards can display richer and more diverse content, providing a more friendly and pleasant visual experience~~ (Feishu application configuration changes) 0.1.7 ✅
- **Extract environment variables feishuAppId and feishuAppSecret**: Separate Feishu configuration from environment variables, so that it can be set in clients like cursor, supporting a service to be shared by multiple teams.
- ~~**Support knowledge base and my document library**: Realize knowledge base, my document library node traversal, node creation, file creation, search, etc.~~ (Feishu application configuration changes) 0.1.8 ✅
- **Version update notification**: Provide relevant prompts and explanations when releasing new versions.
- ~~**stdio mode user authentication issue**: Fix stdio mode Feishu user authentication failure issue~~ 0.1.9 ✅
- ~~**Permission check function configurable**: Make the permission check function a configurable option, support control through environment variable `FEISHU_SCOPE_VALIDATION` or command-line parameter `--feishu-scope-validation`, default enable, meet different user scenarios~~ 0.2.0 ✅
- ~~**Optimize cache directory: save token and other caches to system-level configuration directory~~ 0.2.2 ✅ Thanks to [Molunerfinn](https://github.com/Molunerfinn), [leeeezx](https://github.com/leeeezx), [Master-cai](https://github.com/Master-cai) for their suggestions and code contributions
- ~~**Optimize mcpTool related code**: Rebuild code structure to lay a foundation for adding more functions~~ 0.2.3 ✅
- ~~**Support task management**: List, create, update, and delete Feishu tasks, support subtasks and member management~~ 0.2.4 ✅
- ~~**Support user information query**: Search for users by name or batch obtain by ID, facilitate task assignment and document collaboration~~ 0.2.4 ✅
- ~~**Tool API layer extraction**: Create a new Tool API layer, corresponding to the tool layer one-to-one, unified parameter verification, data conversion, error mapping, etc.~~ ✅
- ~~**Compatible CLI mode**: Support `feishu-tool <tool-name> '<json>'` command-line invocation, convenient for script and automation scenarios~~ 0.2.6 ✅
- ~~**Complete Skill**: Provide [Feishu-Skill](https://github.com/cso1z/Feishu-Skill), guide Claude Code and other AI Agents to use feishu-mcp CLI in suitable scenarios~~ 0.2.6 ✅
## 🔧 Feishu Configuration Tutorial
**⚠️ Important reminder: Before using, you must complete Feishu application configuration, otherwise, you cannot use this tool normally.**
For instructions on how to create a Feishu application and obtain application credentials, refer to [official tutorial](https://open.feishu.cn/document/home/develop-a-bot-in-5-minutes/create-an-app).
**Detailed Feishu application configuration steps**: For a detailed guide on registering Feishu applications, configuring permissions, and adding document access permissions, please refer to [step-by-step tutorial FEISHU_CONFIG.md](FEISHU_CONFIG.md).
---
## 🏃♂️ Quick Start
### Method 1: Use NPM to run quickly
```bash
npx feishu-mcp@latest --feishu-app-id=<your Feishu app ID> --feishu-app-secret=<your Feishu app secret> --feishu-auth-type=<tenant/user> --enabled-modules=<document,task>
```
### Method 2: Local operation
1. **Clone repository**
```bash
git clone https://github.com/cso1z/Feishu-MCP.git
cd Feishu-MCP
```
2. **Configure environment variables (copy a.env.example and save as .env file)**
3. **Edit .env file**
In the project root directory, find and open the `.env` file with any text editor, and fill in your Feishu application credentials:
```env
FEISHU_APP_ID=cli_xxxxx
FEISHU_APP_SECRET=xxxxx
PORT=3333
FEISHU_AUTH_TYPE=tenant/user
FEISHU_ENABLED_MODULES=document,task
```
4. **Run server**
Method 1: Local operation
- **Install dependencies**
```bash
pnpm install
```
- **Start service**
```bash
pnpm run dev
```
Method 2: Use Docker Compose
- **Start service**
```bash
docker-compose up -d
```
- **View logs**
```bash
docker-compose logs -f
```
---
## 🖥️ feishu-tool CLI Tool
From version `0.2.5`, the `feishu-mcp` npm package comes with `feishu-tool` standalone CLI, which allows direct invocation of all Feishu tools in the terminal or script without starting the MCP server.
### Installation
```bash
# Global installation (recommended)
npm install -g feishu-mcp@latest
```
### Configuration
```bash
# 1. View CLI overview (subcommands + available toolsets)
feishu-tool --help
# 2. View initialization guide (steps to obtain App ID / Secret)
feishu-tool guide
# 3. Write credentials
feishu-tool config set FEISHU_APP_ID cli_xxxxx
feishu-tool config set FEISHU_USER_KEY "$(node -e 'console.log(crypto.randomUUID())')"
# FEISHU_USER_KEY is recommended to be unique for each local user or client
# 4. View current configuration (confirm written correctly)
feishu-tool config
# 5. View detailed parameters of a tool
feishu-tool help create_feishu_document
# 6. Invoke tool
feishu-tool create_feishu_document '{"title": "Test document"}'
```
> Refer to [Feishu-Skill documentation](https://github.com/cso1z/Feishu-Skill) for complete parameter instructions.
---
## ⚙️ Project Configuration
### Environment Variable Configuration
| Variable Name | Required | Description | Default Value |
|--------------|----------|--------------------------------------------------------------------|---------------|
| `FEISHU_APP_ID` | ✅ | Feishu App ID | - |
| `FEISHU_APP_SECRET` | ✅ | Feishu App Secret | - |
| `PORT` | ❌ | Server Port | `3333` |
| `FEISHU_BASE_URL` | ❌ | Feishu API Base URL, Lark International version can be configured as `https://open.larksuite.com/open-apis` | `https://open.feishu.cn/open-apis` |
| `FEISHU_AUTH_BASE_URL` | ❌ | Feishu Authorization Page Domain, Lark International version set to `https://accounts.larksuite.com` | `https://accounts.feishu.cn` |
| `FEISHU_PUBLIC_BASE_URL` | ❌ | The base URL that the service is accessible to the public. If MCP accesses through the intranet address but OAuth callback needs to go through the public domain name, it can be set to `https://mcp.example.com` | - |
| `FEISHU_AUTH_TYPE` | ❌ | Authentication credential type, using `user` (user-level, use user's identity to operate Feishu documents, need OAuth authorization), using `tenant` (application-level, default) | `tenant` |
| `FEISHU_SCOPE_VALIDATION` | ❌ | Whether to enable permission check, set to `false` to disable permission check (applicable to scenarios where only some functions are used) | `true` |
| `FEISHU_ENABLED_MODULES` | ❌ | Enable modules: `document`, `task`, `calendar`, `member`, `all`. task/calendar/member require user authentication | `document` |
| `FEISHU_USER_KEY` | ❌ | User identifier in `stdio/CLI` mode, can be set by `feishu-tool config set FEISHU_USER_KEY <value>` or command-line parameter `--user-key` | `stdio` |
| `FEISHU_REQUIRE_USER_KEY` | ❌ | Whether to require explicit user-key in `user` authentication mode. Default remains compatible; multi-user HTTP/relay scenarios recommend setting to `true` | `false` |
| `FEISHU_ENCRYPTION_KEY` | ❌ | Token cache sensitive field encryption key. Any string, system automatically derives encryption key through SHA-256. Set after `access_token`, `refresh_token`, `client_secret` and other sensitive fields will be encrypted and stored. Docker deployment recommends setting a fixed key | - |
| `MCP_BEARER_TOKEN` | ❌ | MCP Bearer Token authentication token. Set after all HTTP/SSE/StreamableHTTP endpoints will require request header `Authorization: Bearer <token>`, not set to disable authentication. Recommend using random strings like UUID | - |
### Function Module Description
| Module | Description | Authentication Requirement |
|------|------|----------|
| `document` | Documents, folders, search, etc. | tenant / user |
| `task` | Task CRUD | only user |
| `calendar` | Calendar (under development) | only user |
| `member` | User information query | only user |
| `all` | Enable all modules | user loads all |
### Configuration File Method (applicable to Cursor, Cline, etc.)
#### stdio Mode (Recommended)
```
{
"mcpServers": {
"feishu-mcp": {
"command": "npx",
"args": ["-y", "feishu-mcp@latest", "--stdio"],
"env": {
"FEISHU_APP_ID": "<your Feishu App ID>",
"FEISHU_APP_SECRET": "<your Feishu App Secret>",
"FEISHU_AUTH_TYPE": "<tenant/user>",
"FEISHU_ENABLED_MODULES": "document,task",
"FEISHU_USER_KEY": "<your user identifier>"
}
}
}
}
```
#### SSE Mode
```
{
"mcpServers": {
"feishu_local": {
"url": "http://localhost:3333/sse?userKey=123456"
}
}
}
```
#### HTTP Streamable Mode
```
{
"mcpServers": {
"feishu_streamable": {
"url": "http://localhost:3333/mcp?userKey=123456"
}
}
}
```
#### Bearer Token Authentication (Optional)
When `MCP_BEARER_TOKEN` environment variable is configured, all HTTP/SSE/StreamableHTTP endpoints will require the request to carry `Authorization: Bearer <token>` header. Applicable to public deployment scenarios to prevent unauthorized access.
**Configuration Example**:
```env
# .env file
MCP_BEARER_TOKEN=your-secret-token-here
```
**Client Configuration Example (SSE Mode + Bearer Authentication)**:
> ⚠️ Currently, most MCP clients (such as Cursor, Cline) do not support custom request headers in SSE/StreamableHTTP connections. If you need to use Bearer authentication, please confirm your client supports passing `Authorization` headers, or use a reverse proxy (like Nginx) for authentication on the server side.
For clients or API calls that support custom headers:
```bash
# SSE connection example
curl -H "Authorization: Bearer your-secret-token-here" http://localhost:3333/sse?userKey=123456
# StreamableHTTP request example
curl -X POST -H "Authorization: Bearer your-secret-token-here" -H "Content-Type: application/json" http://localhost:3333/mcp?userKey=123456
```
**⚠️ Important Note**: The `userKey` in the URL represents the user's identifier and is a very important configuration. Please fill in and make it as random as possible.
**userKey Passing Method**: Two methods are supported to pass the user identifier
- **URL query parameter**: `?userKey=123456` (recommended, simple configuration)
- **Request header**: `user-key: 123456` (suitable for scenarios where parameters need to be hidden)
## 📝 Usage Tips (Important)
1. ### **Recommended Specify Folder**:
When creating a new document, it is recommended to actively provide the Feishu folder token (can be a specific folder or root folder), so that documents can be located and managed more efficiently. If you are not sure about the specific subfolder, you can let LLM automatically find the most suitable subfolder under the folder you specified to create a new document.
> **How to get folder token?**
> Open the Feishu folder page, copy the link (e.g., `https://.../drive/folder/xxxxxxxxxxxxxxxxxxxxxx`), and the token is the string at the end of the link (e.g., `xxxxxxxxxxxxxxxxxxxxxx`, please do not leak the real token).
2. ### **Image Upload Path Description**:
When running MCP locally, the image path supports both local absolute paths and http/https network images; if in a server environment, only network image links are supported (due to the limitation of the parameter length when cursor calls MCP, it is not supported to directly upload the image file body, please use the image path or link method to upload).
3. ### **Formula Usage Description**:
Ordinary text and formula elements can be mixed in the text block. The formula uses LaTeX syntax, such as: `1+2=3`, `\frac{a}{b}`, `\sqrt{x}`, etc. Supports multiple formulas and ordinary text in the same text block.
4. ### **Using Feishu User Authentication**:
User authentication and tenant authentication have differences in increasing permissions, so **when switching from tenant to user for the first time, you need to pay attention to the configured permissions**; in order to distinguish different users, you need to pass the user identifier userKey, supporting two methods:
- **URL query parameter**: add `?userKey=123456` to the MCP server URL
- **Request header**: pass `user-key: 123456` request header
**This value is the user's unique identifier, so it is better to make it as random as possible**
5. ### **Strongly Recommended Using User Authentication**:
Tenant authentication has many restrictions, such as document access permissions, Feishu openapi compatibility (does not support searching wiki documents), document creation and editing records, etc., which are not as good as user authentication.
6. ### **Task and User Information Function**:
Want to use AI to help you manage Feishu tasks (list to-do, create tasks, assign responsible persons) or find colleague information? Need two steps: ① Use **user authentication** (tenant mode does not provide these capabilities); ② Set `FEISHU_ENABLED_MODULES=document,task` in the configuration. After enabling task, the user query function will be automatically available, no additional configuration is required.
7. ### **Using Lark International Version**:
Feishu domestic version does not need additional configuration. If your team uses **Lark International version or self-built Feishu service**, you need to set additional:
```env
FEISHU_BASE_URL=https://open.larksuite.com/open-apis
FEISHU_AUTH_BASE_URL=https://accounts.larksuite.com
```
8. ### **Intranet Access, Extranet Callback Separation**:
If the MCP client accesses the service through the intranet address (e.g., `http://feishu-mcp:3333/mcp`), but the Feishu OAuth callback must use a public domain name, you can set additionally:
```env
FEISHU_PUBLIC_BASE_URL=https://somo-feishu-mcp.yfgao.net
```
In this way, the client can still connect to the intranet address, and the authorization link returned to the user will use `https://somo-feishu-mcp.yfgao.net/callback` as the callback address.
9. ### **Dynamic Switching of userKey in Multi-Tenant Relay Architecture**:
In the multi-tenant relay architecture, the system integrates and manages tools to uniformly proxy the Feishu MCP service. Since the underlying MCP service instances exist in the session layer reuse, different users' requests actually run in a shared Session context. Therefore, the system needs to support dynamic switching based on the request header transparent transmission `user-key` to achieve tenant identity isolation and context injection, so as to meet the needs of multi-user concurrent access.
**How to switch userKey**:
- In HTTP Streamable mode, subsequent requests can dynamically update the user identifier of the current session by passing the `user-key` request header
- Passing method: add `user-key: <new user identifier>` in the request header
- Example scenario: when user A completes the operation, user B's request carries `user-key: userB`, the system will automatically switch the session to user B's context
> **Note**: This function is only valid in HTTP Streamable mode, SSE and stdio modes do not support dynamic switching.
## 🚨 Troubleshooting
### Permission Problem Troubleshooting
First, check against the configuration problem: [step-by-step tutorial FEISHU_CONFIG.md](FEISHU_CONFIG.md).
#### Problem Confirmation
1. **Check application permissions**: Ensure the application has obtained the necessary document access permissions
2. **Verify document authorization**: Confirm the target document has been authorized to the application or the group where the application belongs
3. **Check available range**: Ensure the available range of the application release version includes the document owner
#### Permission Verification and Troubleshooting
1. Get token: [self-built application to obtain app_access_token](https://open.feishu.cn/api-explorer?apiName=app_access_token_internal&project=auth&resource=auth&version=v3)
2. Use the token obtained in step 1 to verify if there is permission to access the document: [get document basic information](https://open.feishu.cn/api-explorer?apiName=get&project=docx&resource=document&version=v1)
### Frequently Asked Questions
- **Application not found**: Check if the application has been published and the available range configuration is correct
- **Insufficient permissions**: Refer to [common issues for cloud documents](https://open.feishu.cn/document/ukTMukTMukTM/uczNzUjL3czM14yN3MTN)
- **Knowledge base access issues**: Refer to [common issues for knowledge base](https://open.feishu.cn/document/server-docs/docs/wiki-v2/wiki-qa)
## 📚 Developer Wiki
Detailed development documents and technical guides provide comprehensive guidance for learners and contributors:
- **[Wiki Home](https://github.com/cso1z/Feishu-MCP/wiki)** - Complete document index and quick navigation
- **[Architecture Design](https://github.com/cso1z/Feishu-MCP/wiki/Architecture-Design)** - Overall architecture and technical stack description
- **[Core Module Details](https://github.com/cso1z/Feishu-MCP/wiki/Core-Module-Details)** - Implementation details and code examples of each module
- **[Authentication and Authorization](https://github.com/cso1z/Feishu-MCP/wiki/Authentication-and-Authorization-Mechanism)** - Token management and multi-user support mechanism
- **[Developer Guide](https://github.com/cso1z/Feishu-MCP/wiki/Developer-Guide)** - Environment setup, development process, debugging techniques
- **[API Reference](https://github.com/cso1z/Feishu-MCP/wiki/API-Reference-Document)** - Detailed documentation of all tool functions
- **[Best Practices](https://github.com/cso1z/Feishu-MCP/wiki/Best-Practices)** - Code specifications, performance optimization, security practices
- **[MCP Protocol Implementation](https://github.com/cso1z/Feishu-MCP/wiki/MCP-Protocol-Implementation)** - MCP protocol details and transmission layer implementation
## 💖 Support the Project
If this project helps you, consider:
- ⭐ Give the project a Star
- 🐛 Report bugs and issues
- 💡 Propose new feature suggestions
- 📖 Improve documentation
- 🔀 Submit Pull Request
Your support is our driving force!
## Star History
[](https://www.star-history.com/#cso1z/feishu-mcp&Timeline)
