feishu-user-plugin 1.2.1 → 1.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "feishu-user-plugin",
-  "version": "1.2.1",
-  "description": "All-in-one Feishu plugin for Claude Code — send messages as yourself, read chats, manage docs/tables/wiki. 46 tools + 9 skills, 3 auth layers.",
+  "version": "1.3.0",
+  "description": "All-in-one Feishu plugin for Claude Code — messaging, docs, bitable, calendar, tasks, drive. 76 tools + 9 skills, 3 auth layers.",
   "main": "src/index.js",
   "bin": {
     "feishu-user-plugin": "src/cli.js"

package/skills/feishu-user-plugin/references/CLAUDE.md

@@ -3,17 +3,17 @@
 ## What This Is
 All-in-one Feishu plugin for Claude Code with three auth layers:
 - **User Identity** (cookie auth): Send messages (text, image, file, post, sticker, audio) as yourself
-- **Official API** (app credentials): Read group messages, docs, tables, wiki, drive, contacts
+- **Official API** (app credentials): Read group messages, docs, tables, wiki, drive, contacts, upload files
 - **User OAuth UAT** (user_access_token): Read P2P chat history, list all user's chats
 
-## Tool Categories
+## Tool Categories (76 tools)
 
 ### User Identity — Messaging (reverse-engineered, cookie-based)
-- `send_to_user` — Search user + send text (one step, most common)
-- `send_to_group` — Search group + send text (one step)
+- `send_to_user` — Search user + send text (one step, most common). Returns candidates if multiple matches.
+- `send_to_group` — Search group + send text (one step). Returns candidates if multiple matches.
 - `send_as_user` — Send text to any chat by ID, supports reply threading (root_id/parent_id)
-- `send_image_as_user` — Send image (requires image_key from upload)
-- `send_file_as_user` — Send file (requires file_key from upload)
+- `send_image_as_user` — Send image (requires image_key from `upload_image`)
+- `send_file_as_user` — Send file (requires file_key from `upload_file`)
 - `send_post_as_user` — Send rich text with title + formatted paragraphs
 - `send_sticker_as_user` — Send sticker/emoji
 - `send_audio_as_user` — Send audio message
@@ -21,64 +21,176 @@ All-in-one Feishu plugin for Claude Code with three auth layers:
 ### User Identity — Contacts & Info
 - `search_contacts` — Search users/groups by name
 - `create_p2p_chat` — Create/get P2P chat
-- `get_chat_info` — Group details (name, members, owner)
-- `get_user_info` — User display name lookup (from search cache)
+- `get_chat_info` — Group details (name, members, owner). Supports both oc_xxx and numeric chat_id (Official API + protobuf fallback)
+- `get_user_info` — User display name lookup (official API first, cookie cache fallback)
 - `get_login_status` — Check cookie, app, and UAT status
 
 ### User OAuth UAT Tools (P2P chat reading)
-- `read_p2p_messages` — Read P2P (direct message) chat history. chat_id accepts both numeric IDs (from create_p2p_chat) and oc_xxx format.
+- `read_p2p_messages` — Read P2P (direct message) chat history. chat_id accepts both numeric IDs (from create_p2p_chat) and oc_xxx format. Returns newest messages first by default.
 - `list_user_chats` — List group chats the user is in. Note: API only returns groups, not P2P. For P2P, use: `search_contacts` → `create_p2p_chat` → `read_p2p_messages`.
 
 ### Official API Tools (app credentials)
-- `list_chats` / `read_messages` — Chat history (accepts chat name, oc_ ID, or numeric ID; auto-falls back to UAT for external groups)
-- `reply_message` / `forward_message` — Message operations (as bot). reply_message only works for text messages.
-- `search_docs` / `read_doc` / `create_doc` — Document operations
-- `list_bitable_tables` / `list_bitable_fields` / `search_bitable_records` — Table queries
-- `create_bitable_record` / `update_bitable_record` — Table writes
+- `list_chats` / `read_messages` — Chat history (read_messages accepts chat name, oc_ ID, or numeric ID; auto-resolves via bot's group list → im.chat.search → search_contacts). **Auto-falls back to UAT for external groups the bot cannot access.** Returns newest messages first by default. Messages include sender names.
+- `send_message_as_bot` — Bot sends message to any chat (text, post, interactive, etc.)
+- `reply_message` / `forward_message` — Message operations (as bot)
+- `delete_message` / `update_message` — Recall or edit bot's own messages
+- `add_reaction` / `delete_reaction` — Emoji reactions on messages
+- `pin_message` / `unpin_message` — Pin/unpin messages in chat
+- `create_group` / `update_group` — Create and manage group chats
+- `list_members` / `add_members` / `remove_members` — Group membership management
+- `search_docs` / `read_doc` / `get_doc_blocks` / `create_doc` — Document operations
+- `create_doc_block` / `update_doc_block` / `delete_doc_blocks` — Document content editing (insert/update/delete blocks)
+- `create_bitable` — Create a new Bitable (multi-dimensional table) app
+- `list_bitable_tables` / `create_bitable_table` — Table management
+- `list_bitable_fields` / `create_bitable_field` / `update_bitable_field` / `delete_bitable_field` — Field (column) management
+- `list_bitable_views` — List views in a table
+- `search_bitable_records` — Query records with filter/sort
+- `create_bitable_record` / `update_bitable_record` / `delete_bitable_record` — Single record CRUD
+- `batch_create_bitable_records` / `batch_update_bitable_records` / `batch_delete_bitable_records` — Batch operations (max 500/call)
 - `list_wiki_spaces` / `search_wiki` / `list_wiki_nodes` — Wiki
 - `list_files` / `create_folder` — Drive
+- `copy_file` / `move_file` / `delete_file` — Drive file operations (copy, move, delete)
+- `upload_image` / `upload_file` — Upload image/file, returns key for send_image/send_file
 - `find_user` — Contact lookup by email/mobile
+- `list_calendars` / `create_calendar_event` / `list_calendar_events` / `delete_calendar_event` — Calendar management
+- `get_freebusy` — Check user availability
+- `create_task` / `get_task` / `list_tasks` / `update_task` / `complete_task` — Task management
 
 ## Usage Patterns
+
+### Messaging
 - Send text as yourself → `send_to_user` or `send_to_group`
-- Send rich content → `send_post_as_user` (formatted text), `send_image_as_user` (images)
+- Send image → `upload_image` → `send_image_as_user`
+- Send file → `upload_file` → `send_file_as_user`
+- Send rich content → `send_post_as_user` (formatted text with links, @mentions)
+- Reply as user in thread → `send_as_user` with root_id
+- Reply as bot → `reply_message` (official API)
+
+### Reading
 - Read any group chat history → `read_messages` with chat name or ID (auto-handles external groups via UAT fallback)
 - Read P2P chat history → `search_contacts` → `create_p2p_chat` → `read_p2p_messages`
-- Reply as user in thread → `send_as_user` with root_id
-- Reply as bot → `reply_message` (official API, text messages only)
+- Get chat details → `get_chat_info` (supports both oc_xxx and numeric ID)
+
+### Bitable (Multi-dimensional Tables)
+- Create a bitable from scratch → `create_bitable` → `create_bitable_table` → `create_bitable_field`
+- Query data → `list_bitable_tables` → `list_bitable_fields` → `search_bitable_records`
+- Single record CRUD → `create_bitable_record` / `update_bitable_record` / `delete_bitable_record`
+- Bulk operations → `batch_create_bitable_records` / `batch_update_bitable_records` / `batch_delete_bitable_records` (max 500/call)
+- Manage fields → `create_bitable_field` / `update_bitable_field` (requires type param) / `delete_bitable_field`
+
+### Group Management
+- Create a group → `create_group` with name and optional member open_ids
+- Add/remove members → `add_members` / `remove_members` with chat_id + user open_ids
+- List members → `list_members`
+
+### Document Editing
+- Create doc with content → `create_doc` → `create_doc_block` (use document_id as parent_block_id for root)
+- Edit existing block → `get_doc_blocks` to find block_id → `update_doc_block`
+- Delete blocks → `delete_doc_blocks` with start/end index range
+
+### Calendar
+- View schedule → `list_calendars` → `list_calendar_events`
+- Create event → `create_calendar_event` with calendar_id, summary, start/end time
+- Check availability → `get_freebusy` with user open_ids and time range
+
+### Tasks
+- Create task → `create_task` with summary, optional description/due
+- Track tasks → `list_tasks` → `update_task` / `complete_task`
+
+### Diagnostics
 - Diagnose issues → `get_login_status` first
 
 ## Auth & Session
-- **LARK_COOKIE**: Required for user identity tools. Session auto-refreshed every 4h via heartbeat.
+- **LARK_COOKIE**: Required for user identity tools. Session auto-refreshed every 4h via heartbeat and persisted to config.
 - **LARK_APP_ID + LARK_APP_SECRET**: Required for official API tools.
-- **LARK_USER_ACCESS_TOKEN + LARK_USER_REFRESH_TOKEN**: Required for P2P reading. Auto-refreshed via refresh_token.
+- **LARK_USER_ACCESS_TOKEN + LARK_USER_REFRESH_TOKEN**: Required for P2P reading. Auto-refreshed on expiry (error codes 99991668/99991663/99991677). Token auto-persisted to MCP config on refresh.
+- Cookie expiry: sl_session has 12h max-age, auto-refreshed by heartbeat every 4h.
+- UAT expiry: 2h, auto-refreshed via refresh_token.
+- Refresh token expiry: 7 days. Use `keepalive` cron to prevent expiration.
 
-## Automated Cookie Setup via Playwright
+## Required Environment Variables (ALL are required for full functionality)
+
+| Variable | Purpose |
+|----------|---------|
+| LARK_COOKIE | User identity messaging |
+| LARK_APP_ID | Official API access |
+| LARK_APP_SECRET | Official API access |
+| LARK_USER_ACCESS_TOKEN | P2P chat reading |
+| LARK_USER_REFRESH_TOKEN | UAT auto-refresh |
+
+All 5 must be configured. Without UAT, `read_p2p_messages` and `list_user_chats` will not work.
+
+## Installation
+
+### Config location
+
+Credentials are stored in `~/.claude.json` top-level `mcpServers` (global — works in all directories).
+**Do NOT put credentials in project-level config** (`projects[*].mcpServers` or `.mcp.json`) — this causes scope issues.
+
+### Non-interactive setup (for Claude Code agents)
+
+```bash
+npx feishu-user-plugin setup --app-id <APP_ID> --app-secret <APP_SECRET>
+```
 
-When LARK_COOKIE is missing or expired, obtain it using Playwright MCP.
+Writes config to `~/.claude.json` top-level `mcpServers` without any interactive prompts. Supports `--cookie` flag too.
+
+### Interactive setup
+
+```bash
+npx feishu-user-plugin setup    # Interactive setup wizard
+npx feishu-user-plugin oauth    # Get OAuth UAT tokens
+npx feishu-user-plugin status   # Check auth status
+npx feishu-user-plugin keepalive # Refresh cookie + UAT (for cron jobs)
+```
+
+### Token auto-renewal via cron (optional)
+
+To keep tokens alive even when Claude Code is closed:
+
+```bash
+crontab -e
+# Add: 0 */4 * * * npx feishu-user-plugin keepalive >> /tmp/feishu-keepalive.log 2>&1
+```
+
+## Automated Cookie Setup via Playwright
 
 ### Prerequisites
-Playwright MCP must be available. If not:
-> Run: `npx @anthropic-ai/claude-code mcp add playwright -- npx @anthropic-ai/mcp-server-playwright`
-> Then restart Claude Code.
+Playwright MCP must be available. If not installed:
+> Run: `npx @anthropic-ai/claude-code mcp add playwright -- npx @anthropic-ai/mcp-server-playwright` then restart Claude Code.
 
-### Automated Flow — FOLLOW EXACTLY
+### Automated Flow — FOLLOW EXACTLY, DO NOT IMPROVISE
 
-**Step 1: Clear cookies first** (Playwright uses persistent browser profile that may have a DIFFERENT account cached):
+**Step 1: Clear existing browser session (MANDATORY)**
+
+Playwright MCP uses Edge's persistent profile. It may have a cached login from a DIFFERENT Feishu account. You MUST clear cookies first:
+
+```
+browser_run_code:
+  await context.clearCookies();
+```
+
+Then navigate:
 ```
-browser_run_code: await context.clearCookies();
 browser_navigate: https://www.feishu.cn/messenger/
 ```
 
-**Step 2: Show QR code and wait for login**:
+**Step 2: Wait for user to scan QR code**
+
+Take a screenshot to show the QR code:
 ```
 browser_take_screenshot
 ```
-Poll `browser_snapshot` every 5s until URL changes from `/accounts/`.
 
-**Step 3: Extract cookie — TWO-STEP approach** (NEVER use browser_run_code output directly as cookie):
+Tell the user: "Please scan the QR code with Feishu mobile app to log in. Make sure you use the correct account."
+
+Poll with `browser_snapshot` every 5 seconds until the URL changes away from `/accounts/` (indicating login complete).
+
+**Step 3: Extract cookie — TWO-STEP approach (MANDATORY)**
+
+NEVER use `browser_run_code` output directly as the cookie string. Its output includes `### Result\n` markdown prefix, page snapshots, and console logs that contaminate the cookie.
 
-Step 3a via `browser_run_code`:
+Step 3a — Store cookie in page context via `browser_run_code`:
 ```js
 const cookies = await page.context().cookies('https://www.feishu.cn');
 const str = cookies.map(c => c.name + '=' + c.value).join('; ');
@@ -86,47 +198,170 @@ await page.evaluate(s => { window.__COOKIE__ = s; }, str);
 return 'Stored ' + cookies.length + ' cookies, length=' + str.length;
 ```
 
-Step 3b via `browser_evaluate`:
+Step 3b — Read the clean cookie string via `browser_evaluate`:
 ```js
 window.__COOKIE__
 ```
 
-**Step 4: Validate** — Must be pure ASCII, contain `session=` and `sl_session=`, length 500-5000. If >10000, it's contaminated.
+This two-step approach ensures the cookie string is clean, with no markdown prefix or page content mixed in.
 
-**Step 5: Write config** using exact format:
-```json
-{
-  "feishu-user-plugin": {
-    "command": "npx",
-    "args": ["-y", "feishu-user-plugin"],
-    "env": {
-      "LARK_COOKIE": "<cookie>",
-      "LARK_APP_ID": "<id>",
-      "LARK_APP_SECRET": "<secret>",
-      "LARK_USER_ACCESS_TOKEN": "<uat>",
-      "LARK_USER_REFRESH_TOKEN": "<refresh>"
-    }
-  }
-}
+**Step 4: Validate BEFORE writing (MANDATORY)**
+
+Check the cookie string:
+1. Must be pure ASCII — no Chinese characters, no markdown (`###`), no HTML
+2. Must contain `session=` and `sl_session=`
+3. Length should be 500-5000 characters. If >10000, it is contaminated — DO NOT write it.
+4. Must NOT start with `###` or contain `\n` followed by non-cookie content
+
+If validation fails: STOP. Debug the extraction. Do NOT write a bad cookie to config.
+
+**Step 5: Write cookie to config**
+
+Use `persistToConfig` or directly update the `LARK_COOKIE` field in `~/.claude.json` → `mcpServers` → `feishu-user-plugin` → `env`.
+
+**Step 6: Run OAuth for UAT (if not already configured)**
+
+```bash
+npx feishu-user-plugin oauth
+```
+
+This opens a browser for OAuth consent. After completion, tokens are auto-saved to `~/.claude.json`.
+
+**Step 7: Close browser and prompt restart**
+
+```
+browser_close
 ```
 
-## Troubleshooting
+Tell user to restart Claude Code. Only ONE restart should be needed.
+
+## Troubleshooting Guide
+
+### If MCP tools are not available
+1. Check `~/.claude.json` — config must be in **top-level** `mcpServers`, not inside `projects[*]`
+2. Restart Claude Code after config changes
+3. After restart, tools may take a few seconds to register — if first call fails with "No such tool", wait and retry once
 
 ### If cookie authentication fails
+- `document.cookie` in browser console CANNOT access HttpOnly cookies (`session`, `sl_session`)
+- **Correct method**: Network tab → first request → Request Headers → Cookie → Copy value
 - **Best method**: Playwright two-step extraction (see above)
-- **Manual fallback**: Network tab → first request → Request Headers → Cookie → Copy value
-- Do NOT use `document.cookie` or Application → Cookies (misses HttpOnly cookies)
 
-### If Playwright logs into the wrong account
-- Always `context.clearCookies()` BEFORE navigating to feishu.cn
-- Verify account by checking URL domain after login
+### If Playwright logs into the wrong Feishu account
+- Playwright uses Edge's persistent profile with cached sessions
+- **ALWAYS clear cookies first** with `context.clearCookies()` before navigating to feishu.cn
+
+### If read_messages returns an error
+- Error messages include the actual Feishu error code and description
+- `read_messages` auto-falls back to UAT when bot API fails (e.g. external groups)
+- Chat name resolution: bot's group list → `im.chat.search` → `search_contacts` (cookie)
+- If all three strategies fail, provide the oc_xxx or numeric chat ID directly
 
-### If UAT refresh fails with "invalid_grant" (error 28003/20003/20005)
-- Refresh token expired — re-run `node src/oauth.js` (needs LARK_APP_ID + LARK_APP_SECRET in `.env`)
-- Copy new UAT + refresh token from `.env` to MCP config, then restart Claude Code
+### If UAT refresh fails with "invalid_grant"
+- The refresh token has expired or been revoked — auto-refresh cannot recover this
+- **Fix**: Re-run OAuth: `npx feishu-user-plugin oauth`
+- Then restart Claude Code
+
+### If OAuth fails with "Missing LARK_APP_ID"
+- `oauth.js` reads credentials from `~/.claude.json` MCP config (not .env)
+- Run `npx feishu-user-plugin setup` first, then re-run OAuth
+
+### If two MCP servers are running (duplicate tools)
+- This happens when both `~/.claude.json` mcpServers AND a team-skills plugin have feishu-user-plugin
+- team-skills plugin should NOT have `.mcp.json` — it only provides skills and CLAUDE.md
+- Delete `.mcp.json` from the team-skills plugin directory if it exists
 
 ### If list_user_chats doesn't return P2P chats
-- Expected — API only returns groups. Use: `search_contacts` → `create_p2p_chat` → `read_p2p_messages`.
+- This is expected — the API only returns group chats
+- **Correct P2P flow**: `search_contacts` → `create_p2p_chat` → `read_p2p_messages`
+
+## Architecture
+
+### Two distribution channels
+- **npm package** (`npx feishu-user-plugin`): MCP server code + skills + CLAUDE.md. For external users.
+- **team-skills plugin**: Skills + CLAUDE.md only (no .mcp.json). For internal team members.
+
+### Config management
+- `src/config.js`: Unified config module. Discovers config in `~/.claude.json` (top-level + project-level) and `.mcp.json`.
+- `setup` always writes to `~/.claude.json` top-level `mcpServers` (global).
+- `persistToConfig()` finds the correct config entry and writes back (used by heartbeat + UAT refresh).
+
+## Development & Publishing
+
+### Publishing to npm
+
+```bash
+# 1. Update version in package.json
+# 2. Commit and tag
+git add -A && git commit -m "v1.2.1: description"
+git tag v1.2.1
+git push && git push --tags
+# 3. GitHub Actions auto-publishes to npm on tag push
+```
+
+GitHub Actions workflow (`.github/workflows/publish.yml`) auto-publishes on `v*` tags.
+NPM_TOKEN is stored as a GitHub repo secret.
+
+### Syncing to team-skills
+
+After publishing, sync plugin assets to team-skills:
+
+```bash
+# From the feishu-user-plugin repo:
+cp -r skills/ /path/to/team-skills/plugins/feishu-user-plugin/skills/
+cp .claude-plugin/plugin.json /path/to/team-skills/plugins/feishu-user-plugin/.claude-plugin/
+# Do NOT copy .mcp.json — team-skills plugin should not have one
+```
+
+## Development Workflow
+
+### Keeping ROADMAP.md up to date
+- When completing a feature or fixing a bug, check the corresponding item in ROADMAP.md as `[x]` done
+- When discovering new bugs, limitations, or feature ideas during development, add them to the appropriate section in ROADMAP.md
+- When a version is released (tag pushed), move completed items under the "已完成" section with the version number
+- When researching a direction and deciding not to implement, add it to "已调研但暂不实施" with the reasoning
+
+### When adding new tools
+1. Add method to `src/official.js`（Official API）or `src/client.js`（Cookie 身份）
+2. Add tool definition to `TOOLS` array in `src/index.js`
+3. Add handler case in `handleTool()` switch in `src/index.js`
+4. Run `node -c src/official.js && node -c src/index.js` to verify syntax
+5. Update this file (CLAUDE.md) — tool count, tool list, usage patterns
+6. Update ROADMAP.md if relevant
+
+### When fixing bugs
+1. Write a standalone test script (`node -e "..."`) to reproduce the bug before fixing
+2. After fixing, verify with the same script
+3. If the bug affects MCP tool behavior, test via MCP tool call after server restart
+
+### Commit conventions
+- `feat:` new tools or capabilities
+- `fix:` bug fixes
+- `docs:` CLAUDE.md, ROADMAP.md, README updates
+- `chore:` dependencies, CI, config changes
+
+### Publishing
+1. Update `version` in `package.json`
+2. `git add <files> && git commit -m "v1.x.x: description"`
+3. `git tag v1.x.x && git push && git push --tags`
+4. GitHub Actions auto-publishes to npm. Users get the new version on next Claude Code restart.
+
+### Syncing to team-skills (after any CLAUDE.md or skills change)
+1. Copy CLAUDE.md to skill reference: `cp CLAUDE.md skills/feishu-user-plugin/references/CLAUDE.md`
+2. Sync to team-skills repo: `cp -r skills/ /Users/abble/team-skills/plugins/feishu-user-plugin/skills/`
+3. Also sync plugin.json: `cp .claude-plugin/plugin.json /Users/abble/team-skills/plugins/feishu-user-plugin/.claude-plugin/`
+4. Commit and push both repos
+
+### Testing a tool
+- For Official API tools: can test directly via MCP tool call or standalone script using `readCredentials()` from `src/config.js`
+- For Cookie tools: need active session, test via MCP tool call
+- Always verify `_safeSDKCall` handles the response format (multipart uploads return data at top level, not nested under `.data`)
 
-### If reply_message fails with error 230054
-- Only text messages can be replied to via this API.
+## Known Limitations
+- CARD message type (type=14) not yet implemented — complex JSON schema
+- External tenant users may not be resolvable via `get_user_info` (contact API scope limitation)
+- Cookie auth requires human interaction (QR scan) — cannot be fully automated
+- Refresh token expires after 7 days without use — set up `keepalive` cron to prevent this
+- `update_bitable_field` requires `type` parameter even when only changing field name (Feishu API requirement)
+- `list_wiki_spaces` may return empty if bot lacks `wiki:wiki:readonly` permission
+- `search_wiki` uses same API as `search_docs` — `docs_types` filter may not work as expected

package/src/index.js

@@ -710,6 +710,384 @@ const TOOLS = [
       },
     },
   },
+
+  // ========== IM — Bot Send / Edit / Delete ==========
+  {
+    name: 'send_message_as_bot',
+    description: '[Official API] Send a message as the bot to any chat. Supports text, post, interactive, etc.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chat_id: { type: 'string', description: 'Target chat_id (oc_xxx) or open_id' },
+        msg_type: { type: 'string', description: 'Message type: text, post, image, interactive, etc.', enum: ['text', 'post', 'image', 'interactive', 'share_chat', 'share_user', 'audio', 'media', 'file', 'sticker'] },
+        content: { description: 'Message content (string or object, auto-serialized). For text: {"text":"hello"}' },
+      },
+      required: ['chat_id', 'msg_type', 'content'],
+    },
+  },
+  {
+    name: 'delete_message',
+    description: '[Official API] Recall/delete a message (bot can only delete its own messages).',
+    inputSchema: {
+      type: 'object',
+      properties: { message_id: { type: 'string', description: 'Message ID (om_xxx)' } },
+      required: ['message_id'],
+    },
+  },
+  {
+    name: 'update_message',
+    description: '[Official API] Edit a sent message (bot can only edit its own messages). Supports text and post.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message_id: { type: 'string', description: 'Message ID (om_xxx)' },
+        msg_type: { type: 'string', description: 'Message type: text or post' },
+        content: { description: 'New content. For text: {"text":"updated text"}' },
+      },
+      required: ['message_id', 'msg_type', 'content'],
+    },
+  },
+
+  // ========== IM — Reactions ==========
+  {
+    name: 'add_reaction',
+    description: '[Official API] Add an emoji reaction to a message.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message_id: { type: 'string', description: 'Message ID (om_xxx)' },
+        emoji_type: { type: 'string', description: 'Emoji type string, e.g. "THUMBSUP", "SMILE", "HEART"' },
+      },
+      required: ['message_id', 'emoji_type'],
+    },
+  },
+  {
+    name: 'delete_reaction',
+    description: '[Official API] Remove an emoji reaction from a message.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message_id: { type: 'string', description: 'Message ID' },
+        reaction_id: { type: 'string', description: 'Reaction ID (from add_reaction response)' },
+      },
+      required: ['message_id', 'reaction_id'],
+    },
+  },
+
+  // ========== IM — Pin Messages ==========
+  {
+    name: 'pin_message',
+    description: '[Official API] Pin a message in a chat.',
+    inputSchema: {
+      type: 'object',
+      properties: { message_id: { type: 'string', description: 'Message ID to pin' } },
+      required: ['message_id'],
+    },
+  },
+  {
+    name: 'unpin_message',
+    description: '[Official API] Unpin a message from a chat.',
+    inputSchema: {
+      type: 'object',
+      properties: { message_id: { type: 'string', description: 'Message ID to unpin' } },
+      required: ['message_id'],
+    },
+  },
+
+  // ========== IM — Chat Management ==========
+  {
+    name: 'create_group',
+    description: '[Official API] Create a new group chat (as bot). Can add initial members.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Group name' },
+        description: { type: 'string', description: 'Group description (optional)' },
+        user_ids: { type: 'array', items: { type: 'string' }, description: 'Initial member open_ids (optional)' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'update_group',
+    description: '[Official API] Update group chat name or description.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chat_id: { type: 'string', description: 'Chat ID (oc_xxx)' },
+        name: { type: 'string', description: 'New group name (optional)' },
+        description: { type: 'string', description: 'New description (optional)' },
+      },
+      required: ['chat_id'],
+    },
+  },
+  {
+    name: 'list_members',
+    description: '[Official API] List all members in a group chat.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chat_id: { type: 'string', description: 'Chat ID (oc_xxx)' },
+        page_size: { type: 'number', description: 'Items per page (default 50)' },
+        page_token: { type: 'string', description: 'Pagination token' },
+      },
+      required: ['chat_id'],
+    },
+  },
+  {
+    name: 'add_members',
+    description: '[Official API] Add users to a group chat.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chat_id: { type: 'string', description: 'Chat ID (oc_xxx)' },
+        user_ids: { type: 'array', items: { type: 'string' }, description: 'Array of user open_ids to add' },
+      },
+      required: ['chat_id', 'user_ids'],
+    },
+  },
+  {
+    name: 'remove_members',
+    description: '[Official API] Remove users from a group chat.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chat_id: { type: 'string', description: 'Chat ID (oc_xxx)' },
+        user_ids: { type: 'array', items: { type: 'string' }, description: 'Array of user open_ids to remove' },
+      },
+      required: ['chat_id', 'user_ids'],
+    },
+  },
+
+  // ========== Docs — Block Editing ==========
+  {
+    name: 'create_doc_block',
+    description: '[Official API] Insert content blocks into a document. Add text, headings, lists, etc. after create_doc.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        document_id: { type: 'string', description: 'Document ID' },
+        parent_block_id: { type: 'string', description: 'Parent block ID (use document_id for root)' },
+        children: { type: 'array', description: 'Array of block objects to insert. E.g. [{block_type:2, text:{elements:[{text_run:{content:"Hello"}}]}}]', items: { type: 'object' } },
+        index: { type: 'number', description: 'Insert position (optional, appends to end if omitted)' },
+      },
+      required: ['document_id', 'parent_block_id', 'children'],
+    },
+  },
+  {
+    name: 'update_doc_block',
+    description: '[Official API] Update a specific block in a document (change text content, style, etc.).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        document_id: { type: 'string', description: 'Document ID' },
+        block_id: { type: 'string', description: 'Block ID to update' },
+        update_body: { type: 'object', description: 'Update payload. E.g. {update_text_elements:{elements:[{text_run:{content:"new text"}}]}}' },
+      },
+      required: ['document_id', 'block_id', 'update_body'],
+    },
+  },
+  {
+    name: 'delete_doc_blocks',
+    description: '[Official API] Delete a range of blocks from a document.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        document_id: { type: 'string', description: 'Document ID' },
+        parent_block_id: { type: 'string', description: 'Parent block ID containing the blocks to delete' },
+        start_index: { type: 'number', description: 'Start index (inclusive)' },
+        end_index: { type: 'number', description: 'End index (exclusive)' },
+      },
+      required: ['document_id', 'parent_block_id', 'start_index', 'end_index'],
+    },
+  },
+
+  // ========== Bitable — Additional ==========
+  {
+    name: 'get_bitable_record',
+    description: '[Official API] Get a single record by ID from a Bitable table.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        record_id: { type: 'string', description: 'Record ID' },
+      },
+      required: ['app_token', 'table_id', 'record_id'],
+    },
+  },
+  {
+    name: 'delete_bitable_table',
+    description: '[Official API] Delete a data table from a Bitable app.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID to delete' },
+      },
+      required: ['app_token', 'table_id'],
+    },
+  },
+
+  // ========== Drive — File Operations ==========
+  {
+    name: 'copy_file',
+    description: '[Official API] Copy a file/doc in Drive.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_token: { type: 'string', description: 'File token to copy' },
+        name: { type: 'string', description: 'New file name' },
+        folder_token: { type: 'string', description: 'Destination folder token (optional)' },
+        type: { type: 'string', description: 'File type: file, doc, sheet, bitable, docx, mindnote, slides (optional)' },
+      },
+      required: ['file_token', 'name'],
+    },
+  },
+  {
+    name: 'move_file',
+    description: '[Official API] Move a file to another folder in Drive.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_token: { type: 'string', description: 'File token to move' },
+        folder_token: { type: 'string', description: 'Destination folder token' },
+      },
+      required: ['file_token', 'folder_token'],
+    },
+  },
+  {
+    name: 'delete_file',
+    description: '[Official API] Delete a file/folder from Drive.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        file_token: { type: 'string', description: 'File token to delete' },
+        type: { type: 'string', description: 'Type: file, folder, doc, sheet, bitable, docx, mindnote, slides' },
+      },
+      required: ['file_token'],
+    },
+  },
+
+  // ========== Calendar ==========
+  {
+    name: 'list_calendars',
+    description: '[Official API] List all calendars accessible by the bot.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'create_calendar_event',
+    description: '[Official API] Create a calendar event.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        calendar_id: { type: 'string', description: 'Calendar ID (from list_calendars)' },
+        summary: { type: 'string', description: 'Event title' },
+        start_time: { type: 'string', description: 'Start time (RFC3339 or Unix timestamp string)' },
+        end_time: { type: 'string', description: 'End time (RFC3339 or Unix timestamp string)' },
+        description: { type: 'string', description: 'Event description (optional)' },
+        location: { type: 'string', description: 'Event location (optional)' },
+      },
+      required: ['calendar_id', 'summary', 'start_time', 'end_time'],
+    },
+  },
+  {
+    name: 'list_calendar_events',
+    description: '[Official API] List events in a calendar.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        calendar_id: { type: 'string', description: 'Calendar ID' },
+        start_time: { type: 'string', description: 'Start time filter (Unix timestamp string, optional)' },
+        end_time: { type: 'string', description: 'End time filter (Unix timestamp string, optional)' },
+        page_size: { type: 'number', description: 'Items per page (default 50)' },
+      },
+      required: ['calendar_id'],
+    },
+  },
+  {
+    name: 'delete_calendar_event',
+    description: '[Official API] Delete a calendar event.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        calendar_id: { type: 'string', description: 'Calendar ID' },
+        event_id: { type: 'string', description: 'Event ID to delete' },
+      },
+      required: ['calendar_id', 'event_id'],
+    },
+  },
+  {
+    name: 'get_freebusy',
+    description: '[Official API] Check free/busy status of users for a time range.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        user_ids: { type: 'array', items: { type: 'string' }, description: 'Array of user open_ids to check' },
+        start_time: { type: 'string', description: 'Range start (RFC3339)' },
+        end_time: { type: 'string', description: 'Range end (RFC3339)' },
+      },
+      required: ['user_ids', 'start_time', 'end_time'],
+    },
+  },
+
+  // ========== Tasks ==========
+  {
+    name: 'create_task',
+    description: '[Official API] Create a new task in Feishu Tasks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        summary: { type: 'string', description: 'Task title/summary' },
+        description: { type: 'string', description: 'Task description (optional)' },
+        due: { type: 'string', description: 'Due date/time (RFC3339 or Unix timestamp string, optional)' },
+      },
+      required: ['summary'],
+    },
+  },
+  {
+    name: 'get_task',
+    description: '[Official API] Get task details by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: { task_id: { type: 'string', description: 'Task ID' } },
+      required: ['task_id'],
+    },
+  },
+  {
+    name: 'list_tasks',
+    description: '[Official API] List tasks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page_size: { type: 'number', description: 'Items per page (default 50)' },
+        page_token: { type: 'string', description: 'Pagination token' },
+      },
+    },
+  },
+  {
+    name: 'update_task',
+    description: '[Official API] Update a task (title, description, due date, etc.).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task_id: { type: 'string', description: 'Task ID' },
+        summary: { type: 'string', description: 'New title (optional)' },
+        description: { type: 'string', description: 'New description (optional)' },
+        due: { type: 'string', description: 'New due date (optional)' },
+      },
+      required: ['task_id'],
+    },
+  },
+  {
+    name: 'complete_task',
+    description: '[Official API] Mark a task as complete.',
+    inputSchema: {
+      type: 'object',
+      properties: { task_id: { type: 'string', description: 'Task ID to complete' } },
+      required: ['task_id'],
+    },
+  },
 ];
 
 // --- Server ---
@@ -1035,6 +1413,115 @@ async function handleTool(name, args) {
       return text(`File uploaded: ${r.fileKey}\nUse this file_key with send_file_as_user to send it.`);
     }
 
+    // --- Official API: Bot Send / Edit / Delete ---
+
+    case 'send_message_as_bot': {
+      const r = await getOfficialClient().sendMessageAsBot(args.chat_id, args.msg_type, args.content);
+      return text(`Message sent (bot): ${r.messageId}`);
+    }
+    case 'delete_message':
+      return text(`Message deleted: ${(await getOfficialClient().deleteMessage(args.message_id)).deleted}`);
+    case 'update_message':
+      return text(`Message updated: ${(await getOfficialClient().updateMessage(args.message_id, args.msg_type, args.content)).messageId}`);
+
+    // --- Official API: Reactions ---
+
+    case 'add_reaction':
+      return text(`Reaction added: ${(await getOfficialClient().addReaction(args.message_id, args.emoji_type)).reactionId}`);
+    case 'delete_reaction':
+      return text(`Reaction removed: ${(await getOfficialClient().deleteReaction(args.message_id, args.reaction_id)).deleted}`);
+
+    // --- Official API: Pins ---
+
+    case 'pin_message':
+      return json(await getOfficialClient().pinMessage(args.message_id));
+    case 'unpin_message':
+      return text(`Unpinned: ${(await getOfficialClient().unpinMessage(args.message_id)).deleted}`);
+
+    // --- Official API: Chat Management ---
+
+    case 'create_group':
+      return text(`Group created: ${(await getOfficialClient().createChat({ name: args.name, description: args.description, userIds: args.user_ids })).chatId}`);
+    case 'update_group':
+      return text(`Group updated: ${(await getOfficialClient().updateChat(args.chat_id, { name: args.name, description: args.description })).updated}`);
+    case 'list_members':
+      return json(await getOfficialClient().listChatMembers(args.chat_id, { pageSize: args.page_size, pageToken: args.page_token }));
+    case 'add_members': {
+      const r = await getOfficialClient().addChatMembers(args.chat_id, args.user_ids);
+      return text(r.invalidIds.length ? `Added (invalid IDs: ${r.invalidIds.join(', ')})` : 'Members added');
+    }
+    case 'remove_members': {
+      const r = await getOfficialClient().removeChatMembers(args.chat_id, args.user_ids);
+      return text(r.invalidIds.length ? `Removed (invalid IDs: ${r.invalidIds.join(', ')})` : 'Members removed');
+    }
+
+    // --- Official API: Doc Block Editing ---
+
+    case 'create_doc_block':
+      return json(await getOfficialClient().createDocBlock(args.document_id, args.parent_block_id, args.children, args.index));
+    case 'update_doc_block':
+      return json(await getOfficialClient().updateDocBlock(args.document_id, args.block_id, args.update_body));
+    case 'delete_doc_blocks':
+      return text(`Blocks deleted: ${(await getOfficialClient().deleteDocBlocks(args.document_id, args.parent_block_id, args.start_index, args.end_index)).deleted}`);
+
+    // --- Official API: Bitable Additional ---
+
+    case 'get_bitable_record':
+      return json(await getOfficialClient().getBitableRecord(args.app_token, args.table_id, args.record_id));
+    case 'delete_bitable_table':
+      return text(`Table deleted: ${(await getOfficialClient().deleteBitableTable(args.app_token, args.table_id)).deleted}`);
+
+    // --- Official API: Drive File Operations ---
+
+    case 'copy_file':
+      return json(await getOfficialClient().copyFile(args.file_token, args.name, args.folder_token, args.type));
+    case 'move_file':
+      return text(`File moved: task=${(await getOfficialClient().moveFile(args.file_token, args.folder_token)).taskId}`);
+    case 'delete_file':
+      return text(`File deleted: task=${(await getOfficialClient().deleteFile(args.file_token, args.type)).taskId}`);
+
+    // --- Official API: Calendar ---
+
+    case 'list_calendars':
+      return json(await getOfficialClient().listCalendars());
+    case 'create_calendar_event': {
+      const event = { summary: args.summary, description: args.description || '' };
+      event.start_time = { timestamp: args.start_time };
+      event.end_time = { timestamp: args.end_time };
+      if (args.location) event.location = { name: args.location };
+      return json(await getOfficialClient().createCalendarEvent(args.calendar_id, event));
+    }
+    case 'list_calendar_events':
+      return json(await getOfficialClient().listCalendarEvents(args.calendar_id, {
+        startTime: args.start_time, endTime: args.end_time, pageSize: args.page_size,
+      }));
+    case 'delete_calendar_event':
+      return text(`Event deleted: ${(await getOfficialClient().deleteCalendarEvent(args.calendar_id, args.event_id)).deleted}`);
+    case 'get_freebusy':
+      return json(await getOfficialClient().getFreeBusy(args.user_ids, args.start_time, args.end_time));
+
+    // --- Official API: Tasks ---
+
+    case 'create_task': {
+      const task = { summary: args.summary };
+      if (args.description) task.description = args.description;
+      if (args.due) task.due = { timestamp: args.due };
+      return json(await getOfficialClient().createTask(task));
+    }
+    case 'get_task':
+      return json(await getOfficialClient().getTask(args.task_id));
+    case 'list_tasks':
+      return json(await getOfficialClient().listTasks({ pageSize: args.page_size, pageToken: args.page_token }));
+    case 'update_task': {
+      const task = {};
+      if (args.summary) task.summary = args.summary;
+      if (args.description) task.description = args.description;
+      if (args.due) task.due = { timestamp: args.due };
+      return json(await getOfficialClient().updateTask(args.task_id, task));
+    }
+    case 'complete_task':
+      return text(`Task completed: ${(await getOfficialClient().completeTask(args.task_id)).completed}`);
+
     default:
       return text(`Unknown tool: ${name}`);
   }

package/src/official.js

@@ -177,6 +177,140 @@ class LarkOfficialClient {
     return { messageId: res.data.message_id };
   }
 
+  // --- IM: Send (Bot Identity) ---
+
+  async sendMessageAsBot(chatId, msgType, content, receiveIdType = 'chat_id') {
+    const res = await this._safeSDKCall(
+      () => this.client.im.message.create({
+        params: { receive_id_type: receiveIdType },
+        data: { receive_id: chatId, msg_type: msgType, content: typeof content === 'string' ? content : JSON.stringify(content) },
+      }),
+      'sendMessage'
+    );
+    return { messageId: res.data.message_id };
+  }
+
+  async deleteMessage(messageId) {
+    await this._safeSDKCall(
+      () => this.client.im.message.delete({ path: { message_id: messageId } }),
+      'deleteMessage'
+    );
+    return { deleted: true };
+  }
+
+  async updateMessage(messageId, msgType, content) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.message.patch({
+        path: { message_id: messageId },
+        data: { msg_type: msgType, content: typeof content === 'string' ? content : JSON.stringify(content) },
+      }),
+      'updateMessage'
+    );
+    return { messageId: res.data?.message_id || messageId };
+  }
+
+  // --- IM: Reactions ---
+
+  async addReaction(messageId, emojiType) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.messageReaction.create({
+        path: { message_id: messageId },
+        data: { reaction_type: { emoji_type: emojiType } },
+      }),
+      'addReaction'
+    );
+    return { reactionId: res.data.reaction_id };
+  }
+
+  async deleteReaction(messageId, reactionId) {
+    await this._safeSDKCall(
+      () => this.client.im.messageReaction.delete({
+        path: { message_id: messageId, reaction_id: reactionId },
+      }),
+      'deleteReaction'
+    );
+    return { deleted: true };
+  }
+
+  // --- IM: Pins ---
+
+  async pinMessage(messageId) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.pin.create({ data: { message_id: messageId } }),
+      'pinMessage'
+    );
+    return { pin: res.data.pin };
+  }
+
+  async unpinMessage(messageId) {
+    await this._safeSDKCall(
+      () => this.client.im.pin.delete({ data: { message_id: messageId } }),
+      'unpinMessage'
+    );
+    return { deleted: true };
+  }
+
+  // --- IM: Chat Management ---
+
+  async createChat({ name, description, userIds, botIds } = {}) {
+    const data = {};
+    if (name) data.name = name;
+    if (description) data.description = description;
+    if (userIds) data.user_id_list = userIds;
+    if (botIds) data.bot_id_list = botIds;
+    const res = await this._safeSDKCall(
+      () => this.client.im.chat.create({ params: { user_id_type: 'open_id' }, data }),
+      'createChat'
+    );
+    return { chatId: res.data.chat_id };
+  }
+
+  async updateChat(chatId, { name, description } = {}) {
+    const data = {};
+    if (name) data.name = name;
+    if (description) data.description = description;
+    const res = await this._safeSDKCall(
+      () => this.client.im.chat.update({ path: { chat_id: chatId }, data }),
+      'updateChat'
+    );
+    return { updated: true };
+  }
+
+  async listChatMembers(chatId, { pageSize = 50, pageToken } = {}) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.chatMembers.get({
+        path: { chat_id: chatId },
+        params: { member_id_type: 'open_id', page_size: pageSize, page_token: pageToken },
+      }),
+      'listChatMembers'
+    );
+    return { items: res.data.items || [], hasMore: res.data.has_more, pageToken: res.data.page_token };
+  }
+
+  async addChatMembers(chatId, userIds) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.chatMembers.create({
+        path: { chat_id: chatId },
+        params: { member_id_type: 'open_id' },
+        data: { id_list: userIds },
+      }),
+      'addChatMembers'
+    );
+    return { invalidIds: res.data.invalid_id_list || [] };
+  }
+
+  async removeChatMembers(chatId, userIds) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.chatMembers.delete({
+        path: { chat_id: chatId },
+        params: { member_id_type: 'open_id' },
+        data: { id_list: userIds },
+      }),
+      'removeChatMembers'
+    );
+    return { invalidIds: res.data.invalid_id_list || [] };
+  }
+
   // --- Upload ---
 
   async uploadImage(imagePath, imageType = 'message') {
@@ -250,6 +384,41 @@ class LarkOfficialClient {
     return { items: res.data.items || [] };
   }
 
+  async createDocBlock(documentId, parentBlockId, children, index) {
+    const data = { children };
+    if (index !== undefined) data.index = index;
+    const res = await this._safeSDKCall(
+      () => this.client.docx.documentBlockChildren.create({
+        path: { document_id: documentId, block_id: parentBlockId },
+        data,
+      }),
+      'createDocBlock'
+    );
+    return { blocks: res.data.children || [] };
+  }
+
+  async updateDocBlock(documentId, blockId, updateBody) {
+    const res = await this._safeSDKCall(
+      () => this.client.docx.documentBlock.patch({
+        path: { document_id: documentId, block_id: blockId },
+        data: updateBody,
+      }),
+      'updateDocBlock'
+    );
+    return { block: res.data.block };
+  }
+
+  async deleteDocBlocks(documentId, parentBlockId, startIndex, endIndex) {
+    const res = await this._safeSDKCall(
+      () => this.client.docx.documentBlockChildren.batchDelete({
+        path: { document_id: documentId, block_id: parentBlockId },
+        data: { start_index: startIndex, end_index: endIndex },
+      }),
+      'deleteDocBlocks'
+    );
+    return { deleted: true };
+  }
+
   // --- Chat Info (Official API) ---
 
   async getChatInfo(chatId) {
@@ -387,6 +556,22 @@ class LarkOfficialClient {
     return { items: res.data.items || [] };
   }
 
+  async getBitableRecord(appToken, tableId, recordId) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableRecord.get({ path: { app_token: appToken, table_id: tableId, record_id: recordId } }),
+      'getRecord'
+    );
+    return { record: res.data.record };
+  }
+
+  async deleteBitableTable(appToken, tableId) {
+    await this._safeSDKCall(
+      () => this.client.bitable.appTable.delete({ path: { app_token: appToken, table_id: tableId } }),
+      'deleteTable'
+    );
+    return { deleted: true };
+  }
+
   // --- Wiki ---
 
   async listWikiSpaces() {
@@ -435,6 +620,34 @@ class LarkOfficialClient {
     return { token: res.data.token };
   }
 
+  // --- Drive: File Operations ---
+
+  async copyFile(fileToken, name, folderToken, type) {
+    const data = { name, folder_token: folderToken || '' };
+    if (type) data.type = type;
+    const res = await this._safeSDKCall(
+      () => this.client.drive.file.copy({ path: { file_token: fileToken }, data }),
+      'copyFile'
+    );
+    return { file: res.data.file };
+  }
+
+  async moveFile(fileToken, folderToken) {
+    const res = await this._safeSDKCall(
+      () => this.client.drive.file.move({ path: { file_token: fileToken }, data: { folder_token: folderToken || '' } }),
+      'moveFile'
+    );
+    return { taskId: res.data.task_id };
+  }
+
+  async deleteFile(fileToken, type) {
+    const res = await this._safeSDKCall(
+      () => this.client.drive.file.delete({ path: { file_token: fileToken }, params: { type: type || 'file' } }),
+      'deleteFile'
+    );
+    return { taskId: res.data.task_id };
+  }
+
   // --- Contact ---
 
   async findUserByIdentity({ emails, mobiles } = {}) {
@@ -466,6 +679,111 @@ class LarkOfficialClient {
     return allChats;
   }
 
+  // --- Calendar ---
+
+  async listCalendars() {
+    const res = await this._safeSDKCall(
+      () => this.client.calendar.calendar.list({ params: { page_size: 50 } }),
+      'listCalendars'
+    );
+    return { items: res.data.calendar_list || [] };
+  }
+
+  async createCalendarEvent(calendarId, event) {
+    const res = await this._safeSDKCall(
+      () => this.client.calendar.calendarEvent.create({
+        path: { calendar_id: calendarId },
+        data: event,
+      }),
+      'createCalendarEvent'
+    );
+    return { event: res.data.event };
+  }
+
+  async listCalendarEvents(calendarId, { startTime, endTime, pageSize = 50, pageToken } = {}) {
+    const params = { page_size: pageSize };
+    if (startTime) params.start_time = startTime;
+    if (endTime) params.end_time = endTime;
+    if (pageToken) params.page_token = pageToken;
+    const res = await this._safeSDKCall(
+      () => this.client.calendar.calendarEvent.list({
+        path: { calendar_id: calendarId },
+        params,
+      }),
+      'listCalendarEvents'
+    );
+    return { items: res.data.items || [], hasMore: res.data.has_more, pageToken: res.data.page_token };
+  }
+
+  async deleteCalendarEvent(calendarId, eventId) {
+    await this._safeSDKCall(
+      () => this.client.calendar.calendarEvent.delete({
+        path: { calendar_id: calendarId, event_id: eventId },
+      }),
+      'deleteCalendarEvent'
+    );
+    return { deleted: true };
+  }
+
+  async getFreeBusy(userIds, startTime, endTime) {
+    const res = await this._safeSDKCall(
+      () => this.client.calendar.freebusy.list({
+        data: {
+          time_min: startTime,
+          time_max: endTime,
+          user_id: { user_ids: userIds, id_type: 'open_id' },
+        },
+      }),
+      'getFreeBusy'
+    );
+    return { freebusyList: res.data.freebusy_list || [] };
+  }
+
+  // --- Tasks ---
+
+  async createTask(task) {
+    const res = await this._safeSDKCall(
+      () => this.client.task.task.create({ data: task }),
+      'createTask'
+    );
+    return { task: res.data.task };
+  }
+
+  async getTask(taskId) {
+    const res = await this._safeSDKCall(
+      () => this.client.task.task.get({ path: { task_id: taskId } }),
+      'getTask'
+    );
+    return { task: res.data.task };
+  }
+
+  async listTasks({ pageSize = 50, pageToken } = {}) {
+    const res = await this._safeSDKCall(
+      () => this.client.task.task.list({ params: { page_size: pageSize, page_token: pageToken } }),
+      'listTasks'
+    );
+    return { items: res.data.items || [], hasMore: res.data.has_more, pageToken: res.data.page_token };
+  }
+
+  async updateTask(taskId, task) {
+    const res = await this._safeSDKCall(
+      () => this.client.task.task.patch({
+        path: { task_id: taskId },
+        data: task,
+      }),
+      'updateTask'
+    );
+    return { task: res.data.task };
+  }
+
+  async completeTask(taskId) {
+    const res = await this._safeSDKCall(
+      () => this.client.task.task.complete({ path: { task_id: taskId } }),
+      'completeTask'
+    );
+    return { completed: true };
+  }
+
   // --- Safe SDK Call (extracts real Feishu error from AxiosError) ---
 
   async _safeSDKCall(fn, label = 'API') {