# feishu-user-plugin [Health: Active]

**Category:** 🏢 Workplace & Productivity  
**Repository:** https://github.com/zhuzhen-team/feishu-user-plugin  
**GitHub Stars:** 11  
**npm Downloads (last month):** 651  
**Views:** 7  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/feishu-user-plugin

## Description
Feishu/Lark MCP server + CLI tool. 85 tools, 3 auth layers. Send as user via cookie+protobuf.

## Tools
Capabilities this server exposes over MCP:

- **manage_bitable_app** — [Official API] Manage a Bitable app. action=create (new app, optional wiki_space_id to attach), copy (duplicate an existing app), get_meta (read app metadata).
- **manage_bitable_table** — [Official API] Manage a table inside a Bitable app. action=list, create (with optional initial fields), update (rename), delete.
- **manage_bitable_field** — [Official API] Manage fields (columns) inside a Bitable table. action=list, create, update (Feishu requires `type` even when only renaming), delete.
- **manage_bitable_view** — [Official API] Manage views inside a Bitable table. action=list, create, delete. (Feishu open API does not expose view update — recreate with a new name to change.)
- **manage_bitable_record** — [Official API] Manage records (rows) inside a Bitable table. action=search, get, create, update, delete. create/update/delete accept arrays — single record or up to 500.
- **list_calendars** — [Official API + UAT] List the current user's calendars (primary + shared + subscribed). Requires UAT — app identity only sees calendars it was explicitly invited to. Requires `calendar:calendar:readonly` scope on the OAuth.
- **list_calendar_events** — [Official API + UAT] List events in a calendar within an optional time range. Typical usage: first list_calendars to find calendar_id (primary calendar has type="primary"), then list events in e.g. [now, now+7d] (Unix seconds).
- **get_calendar_event** — [Official API + UAT] Get full details of a single calendar event (summary, description, start/end, attendees, location, attachments, meeting link).
- **create_calendar_event** — [Official API + UAT, v1.3.7] Create a new calendar event. Requires `calendar:calendar.event:create` scope (re-run `npx feishu-user-plugin oauth` after enabling). The current identity (UAT-first) must have writer or owner permission on the calendar.

Time fields: A time object: {timestamp:"<unix-seconds>", timezone?:"Asia/Shanghai"} OR {date:"YYYY-MM-DD"} for all-day events.
- **update_calendar_event** — [Official API + UAT, v1.3.7] Patch fields on an existing calendar event. Pass only the fields you want to change. Requires `calendar:calendar.event:update` scope.
- **delete_calendar_event** — [Official API + UAT, v1.3.7] Delete a calendar event. Requires `calendar:calendar.event:delete` scope.
- **respond_calendar_event** — [Official API + UAT, v1.3.7] Respond to an event invitation. The current identity must be in the event's attendee list. Requires `calendar:calendar.event:reply` scope.
- **get_freebusy** — [Official API + UAT, v1.3.7] Query freebusy windows for one or more users in a time range. Use to find a meeting slot. Requires `calendar:calendar:readonly` (already in default scope set).
- **search_contacts** — [User Identity] Search Feishu users, bots, or group chats by name. Returns IDs.
- **create_p2p_chat** — [User Identity] Create or get a P2P (direct message) chat. Returns numeric chat_id.
- **get_user_info** — [User Identity] Look up a user's display name by user ID.
- **get_login_status** — Check cookie session validity and app credentials status. Also refreshes session.
- **download_message_resource** — [User Identity / Official API] Download an image or file attached to a message so the model can see / store it. v1.3.7 (C2.4) consolidates the v1.3.6 download_image (mode 1) + download_file. UAT-first, falls back to app.

For images, the response includes an inline `image` content block so the model sees pixels. For files, the response includes the bytes as base64 (truncated for display) plus an optional save_path write.

**Size cap:** payloads > 2 MiB MUST pass `save_path`. The Anthropic API rejects responses > 5 MB; we cap at 2 MiB so multipart wrapping has headroom.

**merge_forward children:** Feishu keys media by the parent merge_forward id, not the child id. Use the child's `parentMessageId` field (returned by read_messages with expand_merge_forward) — not the child id.
- **download_doc_image** — [User Identity / Official API] Download an image embedded in a docx document so the model can see it. Pass the `image_token` from `get_doc_blocks` (block.image.token), and optionally the doc/wiki/URL token to scope the lookup. UAT-first.

**Size cap:** payloads > 2 MiB MUST pass `save_path`.
- **search_docs** — [Official API] Search Feishu documents by keyword. UAT-first with app fallback: with user identity (UAT) the search covers docs visible to YOU, including your personal space; via bot it only covers docs shared with the bot. Response carries viaUser; when hasMore is true, pass the returned nextOffset back as offset to page forward.
- **read_doc** — [Official API] Read the raw text content of a Feishu document.
- **get_doc_blocks** — [Official API] Get structured block tree of a document. Returns block types, content, and hierarchy for precise document analysis. Follows pagination internally and returns ALL blocks by default — hasMore:false in the response guarantees the complete tree (pre-v1.3.17 silently capped at 500 blocks). For very large docs, pass max_blocks to bound one call (rounded up to 500/page granularity) and page forward by passing the returned nextPageToken back as page_token; a bounded response carries truncated:true + hasMore:true so partial output is never silent.
- **create_doc** — [Official API] Create a new Feishu document. Can place directly under a Wiki space by passing wiki_space_id (optionally wiki_parent_node_token for nested placement) — the plugin creates the doc in drive then attaches it as a Wiki node.
- **manage_doc_block** — [Official API] Manage content blocks in a document. Single tool replaces v1.3.6 create_doc_block / update_doc_block / delete_doc_blocks.
  action=create — six modes (pass exactly ONE):
    (A) Generic — pass `children` array (e.g. [{block_type:2, text:{...}}]).
    (B) Image from local file — pass `image_path`; plugin uploads and patches.
    (C) Image from token — pass `image_token` (already uploaded).
    (D) File attachment from local file — pass `file_path`; plugin handles VIEW-wrap + replace_file.
    (E) File from token — pass `file_token`.
    (F) Table — pass `table={rows,columns,cells?}`; plugin creates a block_type=31 table (Feishu auto-makes the block_type=32 cells) and fills each provided cell. USE THIS for tables — do NOT hand-build table blocks via `children` (the table block_type is 31, NOT 40; getting it wrong returns invalid_param).
  action=update — generic (pass `update_body`), image-replace (pass `image_token`), or file-replace (pass `file_token`). ⚠ `update_text_elements` REPLACES the block's ENTIRE elements array — it is a full overwrite, NOT a patch/append. Any element you omit (bold runs, links, prefixes) is permanently lost; to change part of a block, read it first (get_doc_blocks) and resend ALL elements.
  action=delete — pass `parent_block_id` + `start_index` + `end_index` (range delete).
`document_id` accepts native ID, wiki node token, or Feishu URL.
- **read_doc_markdown** — [Plugin v1.3.9] Read a Feishu doc as Markdown (vs get_doc_blocks JSON). Saves ~60% tokens for RAG / digest / summarisation use cases. Accepts native docx token, wiki node token, or full Feishu URL. Embedded images / files appear as feishu://image_token/<TOKEN> placeholders — call download_doc_image for the binary if needed.
- **list_files** — [Official API] List files in a Drive folder. UAT-first with app fallback: with user identity (UAT), empty folder_token lists YOUR personal-space ("我的空间") root; via bot it can only see folders shared with the bot (personal-space folders return 403). Response carries viaUser so you know whose view you got. Use the returned file token with manage_drive_file to copy/move/delete.
- **create_folder** — [Official API] Create a new folder in Drive.
- **upload_drive_file** — [Official API] Upload a file from disk to a Feishu Drive folder (drive/v1/files/upload_all, parent_type=explorer). Returns file_token + url. If wiki_space_id is provided, the uploaded file is then attached to that Wiki space via move_docs_to_wiki (obj_type=file). UAT-first with app fallback.
- **manage_drive_file** — [Official API] Manage a Drive file/doc/folder. action=copy (duplicate to a new name + folder), move (relocate, returns task_id), delete (remove, returns task_id). `type` is always required (Feishu rejects with 1061002 / 1062501 otherwise).
- **get_new_events** — [Plugin v1.3.9] Drain real-time events from the machine-level shared event log. v1.3.8 used per-process in-memory buffers (with duplicate-event problem); v1.3.9 uses ~/.feishu-user-plugin/events.jsonl with a single global cursor — every event delivered exactly once across all MCP processes on this machine. Default returns events from the current active profile only; pass profile="*" to see all.
- **manage_ws_status** — [Plugin v1.3.9] Inspect or control the machine-level WS owner. Actions: info (status dump), reconnect (owner-only; restart WS), claim (try become owner; force=true to steal active lock), rotate (owner-only; force events.jsonl rotation), reconfig (owner-only; re-read credentials.json + apply event subscriptions).
- **create_group** — [Official API] Create a new group chat (as bot). Can add initial members.
- **update_group** — [Official API] Update group chat name or description.
- **list_members** — [Official API] List all members in a group chat.
- **manage_members** — [Official API] Add or remove members from a group chat. The Feishu API rejects with code 9499 when the IDs in `member_ids` do not match `member_id_type` — pass `member_id_type` explicitly when using union_id or user_id (default: open_id).
- **get_chat_info** — [Official API + User Identity fallback] Get chat details: name, description, member count, owner. Supports both oc_xxx and numeric chat_id.
- **read_p2p_messages** — [User UAT] Read P2P (direct message) chat history using user_access_token. Works for chats the bot cannot access. Returns newest messages first by default. Auto-expands merge_forward messages into their child messages by default — disable with expand_merge_forward=false. Requires OAuth setup.

**Sender semantics (v1.3.12)**: each message has a `displayLabel` (e.g. `周宇`, `[Bot] Claude聊天助手`, `[匿名]`, `[系统]`, `[已撤回] 怪兽`) — prefer it over raw `senderId` when narrating who-said-what. Also surfaced: `senderType` (user|app|anonymous), `senderIdType` (open_id|union_id|user_id), `senderTenantKey`, `isExternal` (cross-tenant), `isRecalled`, `isThreadReply` (parent_id present).
- **list_user_chats** — [User UAT] List group chats the user is in. Note: only returns groups, not P2P. For P2P chats, use search_contacts → create_p2p_chat → read_p2p_messages. Requires OAuth setup.
- **list_chats** — [Official API] List all chats the bot has joined. Returns chat_id, name, type.
- **read_messages** — [Official API + UAT fallback] Read message history from any group. Accepts oc_xxx ID, numeric ID, or chat name (auto-searched). Auto-falls back to UAT for external groups the bot cannot access. Returns newest messages first by default, with sender names resolved. Auto-expands merge_forward messages into their child messages (with original sender / time / content preserved) by default — disable with expand_merge_forward=false. Text messages have URLs extracted into `urls`; Feishu doc links are additionally surfaced as `feishuDocs` so agents can feed them straight into read_doc / get_doc_blocks.

**Sender semantics (v1.3.12)**: each message has a `displayLabel` (e.g. `周宇`, `[Bot] Claude聊天助手`, `[匿名]`, `[系统]`, `[已撤回] 怪兽`) — prefer it over raw `senderId` when narrating who-said-what. Also surfaced: `senderType` (user|app|anonymous), `senderIdType` (open_id|union_id|user_id), `senderTenantKey`, `isExternal` (cross-tenant), `isRecalled`, `isThreadReply` (parent_id present). **merge_forward children** carry `originChatId` (the chat the conversation came from, NOT the chat you queried) and best-effort `forwardedFromChatName` — do NOT treat children as native messages of the current group.
- **search_messages** — [User UAT, v1.3.12] Search the user's IM history by keyword. Wraps Feishu `POST /open-apis/search/v2/message`. Requires UAT with the `search:message` scope (re-run `npx feishu-user-plugin oauth` after v1.3.12 SCOPES update). Feishu does NOT expose a bot-path search; if you only have app credentials this tool will error.

Returns `{items, pageToken, hasMore}` where each item is a `{message_id, chat_id, ...}` pointer — call `read_messages(chat_id)` or `read_p2p_messages(chat_id)` to fetch the full message bodies if needed. The pointer-only return keeps the response token-light when searching across many chats.

Filter knobs (all optional):
- `chat_ids`: only search inside these chats (oc_xxx)
- `from_ids`: messages sent by these users (ou_xxx / union_id)
- `at_user_ids`: messages that @-mention these users
- `message_types`: e.g. `["text", "post"]`
- `from_types`: e.g. `["user", "anonymous"]`
- **send_message_as_bot** — [Official API] Send a message as the bot to any chat. Supports text, post, interactive, etc. This is the reliable path for @-mentions: include `<at user_id="ou_xxx">Name</at>` inline in text content and Feishu resolves it to a real @-notification.
- **reply_message** — [Official API] Reply to a specific message by message_id (as bot). Only works for text messages; other types return error 230054.
- **forward_message** — [Official API] Forward a message to another chat or user. `receive_id` may be a group chat_id (oc_xxx), an open_id (ou_xxx), a union_id, a user_id, or an email — set `receive_id_type` to match (default: chat_id).
- **delete_message** — [Official API] Recall/delete a message (bot can only delete its own messages).
- **update_message** — [Official API] Edit a sent message (bot can only edit its own messages). Feishu supports edit only for `text` and `interactive` (card) messages — other types (post, image, file, etc.) are rejected by the API.
- **pin_message** — [Official API] Pin or unpin a message in a chat.
- **add_reaction** — [Official API] Add an emoji reaction to a message.
- **delete_reaction** — [Official API] Remove an emoji reaction from a message.
- **send_as_user** — [User Identity] Send a text message as the logged-in Feishu user. Supports reply threading and real @-mentions (triggers push notifications).
- **send_to_user** — [User Identity] Search user by name → create P2P chat → send text message. All in one step.
- **send_to_group** — [User Identity] Search group by name → send text message. All in one step.
- **batch_send** — [User Identity / Official API] Send the same or different content to multiple targets in one call. Each target dispatches sequentially with a small delay (anti-rate-limit) and reports per-target success/error. Identity is the cookie user (user-identity sends) unless target.via=bot. Use for broadcast / fan-out scenarios.
- **send_image_as_user** — [User Identity, v1.3.9] Send an image as the logged-in user (NOT bot). Requires image_key from a prior upload_image call. Cookie-protobuf wire format requires both imageKey + thumbnailKey — when no separate thumbnail is provided, plugin defaults thumbnailKey to imageKey (Feishu accepts this for messenger-uploaded images). Width/height/mime/size are optional metadata; Feishu auto-derives display sizing on its side.
- **send_file_as_user** — [User Identity] Send a file as the logged-in user. Requires file_key (upload via Official API first).
- **send_post_as_user** — [User Identity] Send a rich text (POST) message with title and formatted paragraphs. Supports real @-mentions that trigger notifications.
- **send_card_as_user** — [v1.3.9+: bot-only] Send an interactive Feishu card to a chat via bot identity (Official API). User-identity cookie protobuf path is server-side disabled at the auth tier — confirmed by exhaustive brute-force in v1.3.9, see scripts/explore-card-protobuf.js. The "as_user" suffix is historical naming kept for backward compat; the tool always routes through bot. Pass `card` as a JSON object (Feishu card schema, see https://open.feishu.cn/cardkit).
- **list_user_okrs** — [Official API + UAT] List a user's OKRs. Requires the user's open_id (get yours via get_login_status or search_contacts). Filter by period_ids to narrow to a specific quarter.
- **get_okrs** — [Official API + UAT] Batch-fetch full OKR details (objectives, key results, progress, alignments) by OKR IDs.
- **list_okr_periods** — [Official API + UAT] List OKR periods (quarters / years) defined in the tenant. Use period_ids from this to filter list_user_okrs.
- **create_okr_progress_record** — [Official API + UAT, v1.3.7] Add a progress note to an OKR objective or key result. Feishu requires `source_title`, `source_url`, and a block-structured `content`; this tool exposes a simple `content_text` and auto-wraps it into the single-paragraph block format. Pass richer `content` directly if you need lists / mentions / docs links / images.
- **list_okr_progress_records** — [Official API + UAT, v1.3.7] List progress records for an OKR. Feishu has no native list endpoint — this tool calls get_okrs internally and walks the objective_list / kr_list to extract progress_record IDs (with their target_id and target_type). To read a record's full content, you currently need progressRecord.get (not yet wrapped).
- **delete_okr_progress_record** — [Official API + UAT, v1.3.7] Delete an OKR progress record by its progress_id (from list_okr_progress_records).
- **list_profiles** — [Plugin] List all available identity profiles (each profile has its own LARK_COOKIE / APP_ID / APP_SECRET / UAT). v1.3.9 SSOT: profiles live in ~/.feishu-user-plugin/credentials.json::profiles. Legacy fallback: LARK_PROFILES_JSON env var. Marks the currently active profile.
- **switch_profile** — [Plugin v1.3.9] Switch the active identity profile. Atomically writes credentials.json::active; cached clients in this process are invalidated; cross-process MCPs (Codex / another Claude Code) auto-sync via dispatcher mtime check on next tool call (~10μs). To add a new profile, run `npx feishu-user-plugin setup --profile <name> --app-id ... --app-secret ... --cookie ...` then `npx feishu-user-plugin oauth --profile <name>` for UAT.
- **manage_profile_hints** — [Plugin v1.3.8] Inspect / set / clear profileHints — the resourceKey → profileName cache the auto-switch middleware uses to remember which profile owns each Feishu resource. Useful when a hint goes stale (e.g., a profile lost access to a doc).
- **list_tasks** — [Official API + UAT, v1.3.7] List the current user's tasks. Filter by completion or type.
- **get_task** — [Official API + UAT, v1.3.7] Get full details of a single task by GUID.
- **create_task** — [Official API + UAT, v1.3.7] Create a new task. summary is required; due / members / etc. are optional.
- **update_task** — [Official API + UAT, v1.3.7] Patch a task. **update_fields** is required by Feishu — list which fields to update (e.g. ["summary","due","completed_at"]).
- **complete_task** — [Official API + UAT, v1.3.7] Mark a task complete (or uncomplete it). Convenience wrapper around update_task with completed_at.
- **delete_task** — [Official API + UAT, v1.3.7] Permanently delete a task.
- **manage_task_members** — [Official API + UAT, v1.3.7] Add or remove members on a task. Members are objects {id:"<open_id>", role:"assignee"|"follower", type?:"user", name?:""}.
- **upload_image** — [Official API] Upload an image file to Feishu. Returns image_key for use with send_image_as_user.
- **upload_file** — [Official API] Upload a file to Feishu. Returns file_key for use with send_file_as_user.
- **upload_bitable_attachment** — [Official API] Upload a file as a Bitable attachment (drive/v1/medias/upload_all with parent_type=bitable_image or bitable_file). Returns file_token suitable for writing into a Bitable Attachment-type field via batch_create/update_bitable_records (the field value should be [{file_token}]).
- **list_wiki_spaces** — [Official API] List all accessible Wiki spaces. Follows pagination internally and returns ALL spaces (pre-v1.3.17 silently capped at 50). If the upstream cursor stalls, the response carries truncated:true + cursorUnavailable:true instead of hasMore:true because there is no safe resume cursor.
- **search_wiki** — [Official API] Search Wiki nodes by keyword. UAT-first with app fallback: with user identity (UAT) the search covers wiki spaces visible to YOU; via bot it only covers spaces the bot was invited to. Response carries viaUser; when hasMore is true, pass the returned nextOffset back as offset to page forward.
- **list_wiki_nodes** — [Official API] List nodes in a Wiki space (50 per page). When hasMore is true, pass the returned pageToken back as page_token to fetch the next page. A page may be EMPTY while hasMore is still true (Feishu permission-filters per page) — do not stop at an empty page; keep paging until hasMore is false.
- **get_wiki_node** — [Official API] Resolve a Wiki node token to its underlying object (docx / bitable / sheet / mindnote / file). Returns obj_type + obj_token + space_id so you can read/write the real resource via the usual docx / bitable tools. Accepts bare wiki node token (wikcnXXX), an underlying obj_token (docxXXX / bascnXXX from search_wiki), or a full Feishu /wiki/ URL — the handler tries the wiki endpoint first and falls back to a synthesized node-shape for non-wiki tokens.
- **create_wiki_node** — [Official API] Create a new Wiki node inside a space. obj_type picks the underlying resource (doc/sheet/bitable/mindnote/file/docx/slides). UAT-first so the resource is owned by the user.
- **update_wiki_node** — [Official API] Rename a Wiki node (only `title` is updatable via the wiki API; the underlying resource content is edited via docx/bitable/sheet tools).
- **move_wiki_node** — [Official API] Move a Wiki node to a different parent (within the same space) or to a different space. Pass at least one of target_parent_token / target_space_id.
- **copy_wiki_node** — [Official API] Deep-copy a Wiki node into a different location (and optionally a different space). Underlying resource is duplicated.
- **delete_wiki_node** — [Official API, v1.3.7] Delete a Wiki node. Calls `DELETE /open-apis/wiki/v2/spaces/{space_id}/nodes/{node_token}`. The Feishu SDK does not type this endpoint, so the call goes through raw REST (UAT-first; bot fallback uses `client.request`). **The underlying drive resource (docx / sheet / bitable / file) is NOT deleted** — Feishu treats wiki nodes as pointers. To delete the actual resource as well, follow up with `manage_drive_file(action=delete, type=<obj_type>, file_token=<obj_token>)` (use `get_wiki_node` first to get obj_type / obj_token).

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "feishu-user-plugin": {
    "command": "npx",
    "args": ["-y","feishu-user-plugin"],
    "env": {
      "LARK_COOKIE": "",
      "LARK_APP_ID": "",
      "LARK_APP_SECRET": "",
      "LARK_USER_ACCESS_TOKEN": "",
      "LARK_USER_REFRESH_TOKEN": ""
    }
  }
}
```

**Requires environment variables:** `LARK_COOKIE`, `LARK_APP_ID`, `LARK_APP_SECRET`, `LARK_USER_ACCESS_TOKEN`, `LARK_USER_REFRESH_TOKEN` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What feishu-user-plugin does

The feishu-user-plugin MCP server exposes Feishu/Lark capabilities through MCP and also includes a command-line setup and account-management workflow. Its documented coverage includes instant messaging, group and P2P message reading, documents, Bitable, knowledge bases, cloud storage, calendars, Task v2, OKR, contacts, and real-time events. The repository advertises 85 tools and nine MCP prompts.

Messaging is split between bot or application access and user-identity paths. The cookie-plus-protobuf route supports selected text, post, image, file, card, mention, and batch sending operations, although cards sent through this route fall back to a bot path. The official API is used for capabilities such as reading group messages and managing content resources. User OAuth adds P2P private-message reading, chat listing, and user-owned writes for selected resources.

## How it works

The feishu-user-plugin MCP server runs locally and communicates with the AI client configured to launch it. Credentials remain on the local machine, with the primary credential file stored under `~/.feishu-user-plugin/credentials.json`. The project states that it does not send telemetry or communicate with an author-operated backend.

Three authentication layers can be configured independently:

- A Feishu app ID and secret provide official API access for messaging, documents, tables, knowledge bases, Drive, calendars, tasks, OKR, contacts, and events.
- A user access token and refresh token provide OAuth-based user access, including P2P reads and selected user-owned writes.
- A cookie enables the web-protocol sending path for supported user-identity message operations.

The server also supports multiple profiles. Read operations can retry across profiles after selected access failures, while write operations do not automatically switch profiles. A per-call profile option can pin a request to a named account. Real-time events use one machine-level WebSocket owner and a shared event log so multiple MCP processes can receive each event once.

## Setup and configuration

Node.js 18 or newer is required. The documented setup flow uses the package CLI, beginning with `npx feishu-user-plugin setup --app-id <APP_ID> --app-secret <APP_SECRET>`, followed by `npx feishu-user-plugin oauth` when user OAuth is needed. Cookie credentials can be obtained through the documented Playwright or browser DevTools procedures.

Client configuration is provided for Claude Code, Claude Desktop, Codex, Cursor, VS Code, and Windsurf. The setup command can target a client, such as `--client codex`, or configure both supported targets. Configuration keys and file locations differ by client, so the repository’s client-specific templates should be followed.

## Tools and capabilities

The advertised tool groups include:

- User-identity message sending, including text, posts, files, images, cards, mentions, and batch operations.
- Group and private-message reading, with merge-forward expansion and extraction of linked Feishu documents.
- Document, Bitable, knowledge-base, and Drive operations.
- Calendar, Task v2, OKR, and contact operations.
- WebSocket event status and subscription management.
- Authentication diagnostics and multi-profile management.

Nine prompts provide shortcuts for sending, replying, digesting conversations, searching, working with documents and tables, browsing the wiki or Drive, and checking authentication status.

## Limitations and notes

Cookie credentials may expire after roughly 12–24 hours without a heartbeat and depend on Feishu’s web protocol. Cookie-based sending does not remove the need for a Feishu app for most other capabilities. Image and file sending still require an official API upload to obtain the relevant key, and card sending cannot use the cookie channel.

The real-time WebSocket implementation supports `feishu.cn`, not the Lark international domain. Applications needing email, approvals, attendance, HR, recruiting, or meeting-minutes domains should note that these areas are not listed among the server’s supported capabilities. The project is MIT licensed.

_Full upstream README: https://allmcps.com/mcp/feishu-user-plugin/readme_