feishu-user-plugin 1.2.1 → 1.3.1

package/src/official.js

@@ -1,10 +1,21 @@
 const lark = require('@larksuiteoapi/node-sdk');
 
+// Redirect all Lark SDK logs to stderr.
+// The SDK's defaultLogger.error uses console.log (stdout), which corrupts
+// MCP's JSON-RPC stdio transport and causes session disconnects.
+const stderrLogger = {
+  error: (...msg) => console.error('[lark-sdk][error]:', ...msg),
+  warn:  (...msg) => console.error('[lark-sdk][warn]:', ...msg),
+  info:  () => {},
+  debug: () => {},
+  trace: () => {},
+};
+
 class LarkOfficialClient {
   constructor(appId, appSecret) {
     this.appId = appId;
     this.appSecret = appSecret;
-    this.client = new lark.Client({ appId, appSecret, disableTokenCache: false });
+    this.client = new lark.Client({ appId, appSecret, disableTokenCache: false, logger: stderrLogger, loggerLevel: lark.LoggerLevel.warn });
     this._uat = null;
     this._uatRefresh = null;
     this._uatExpires = 0;
@@ -177,6 +188,139 @@ 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, pinned = true) {
+    if (pinned) {
+      const res = await this._safeSDKCall(
+        () => this.client.im.pin.create({ data: { message_id: messageId } }),
+        'pinMessage'
+      );
+      return { pin: res.data.pin };
+    }
+    await this._safeSDKCall(
+      () => this.client.im.pin.delete({ data: { message_id: messageId } }),
+      'unpinMessage'
+    );
+    return { unpinned: 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 +394,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 +566,64 @@ 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 };
+  }
+
+  async getBitableMeta(appToken) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.app.get({ path: { app_token: appToken } }),
+      'getBitableMeta'
+    );
+    return { app: res.data.app };
+  }
+
+  async updateBitableTable(appToken, tableId, name) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTable.patch({ path: { app_token: appToken, table_id: tableId }, data: { name } }),
+      'updateTable'
+    );
+    return { name: res.data.name };
+  }
+
+  async createBitableView(appToken, tableId, viewName, viewType = 'grid') {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableView.create({ path: { app_token: appToken, table_id: tableId }, data: { view_name: viewName, view_type: viewType } }),
+      'createView'
+    );
+    return { view: res.data.view };
+  }
+
+  async deleteBitableView(appToken, tableId, viewId) {
+    await this._safeSDKCall(
+      () => this.client.bitable.appTableView.delete({ path: { app_token: appToken, table_id: tableId, view_id: viewId } }),
+      'deleteView'
+    );
+    return { deleted: true };
+  }
+
+  async copyBitable(appToken, name, folderId) {
+    const data = { name };
+    if (folderId) data.folder_token = folderId;
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.app.copy({ path: { app_token: appToken }, data }),
+      'copyBitable'
+    );
+    return { app: res.data.app };
+  }
+
   // --- Wiki ---
 
   async listWikiSpaces() {
@@ -435,6 +672,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 +731,53 @@ class LarkOfficialClient {
     return allChats;
   }
 
+  // --- UAT-based creation (resources owned by user, not app) ---
+
+  async createDocAsUser(title, folderId) {
+    const data = { title };
+    if (folderId) data.folder_token = folderId;
+    const result = await this._withUAT(async (uat) => {
+      const res = await fetch('https://open.feishu.cn/open-apis/docx/v1/documents', {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${uat}`, 'content-type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+      return res.json();
+    });
+    if (result.code !== 0) throw new Error(`createDocAsUser failed (${result.code}): ${result.msg}`);
+    return { documentId: result.data.document?.document_id };
+  }
+
+  async createBitableAsUser(name, folderId) {
+    const data = {};
+    if (name) data.name = name;
+    if (folderId) data.folder_token = folderId;
+    const result = await this._withUAT(async (uat) => {
+      const res = await fetch('https://open.feishu.cn/open-apis/bitable/v1/apps', {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${uat}`, 'content-type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+      return res.json();
+    });
+    if (result.code !== 0) throw new Error(`createBitableAsUser failed (${result.code}): ${result.msg}`);
+    return { appToken: result.data.app?.app_token, name: result.data.app?.name, url: result.data.app?.url };
+  }
+
+  async createFolderAsUser(name, parentToken) {
+    const data = { name, folder_token: parentToken || '' };
+    const result = await this._withUAT(async (uat) => {
+      const res = await fetch('https://open.feishu.cn/open-apis/drive/v1/files/create_folder', {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${uat}`, 'content-type': 'application/json' },
+        body: JSON.stringify(data),
+      });
+      return res.json();
+    });
+    if (result.code !== 0) throw new Error(`createFolderAsUser failed (${result.code}): ${result.msg}`);
+    return { token: result.data.token };
+  }
+
   // --- Safe SDK Call (extracts real Feishu error from AxiosError) ---
 
   async _safeSDKCall(fn, label = 'API') {

package/src/setup.js

@@ -12,7 +12,7 @@
 const readline = require('readline');
 const { findMcpConfig, writeNewConfig } = require('./config');
 
-// Parse CLI args: --app-id, --app-secret, --cookie
+// Parse CLI args: --app-id, --app-secret, --cookie, --client
 function parseArgs() {
   const args = {};
   const argv = process.argv.slice(2);
@@ -20,6 +20,7 @@ function parseArgs() {
     if (argv[i] === '--app-id' && argv[i + 1]) args.appId = argv[++i];
     else if (argv[i] === '--app-secret' && argv[i + 1]) args.appSecret = argv[++i];
     else if (argv[i] === '--cookie' && argv[i + 1]) args.cookie = argv[++i];
+    else if (argv[i] === '--client' && argv[i + 1]) args.client = argv[++i];
   }
   return args;
 }
@@ -135,6 +136,20 @@ async function main() {
   const existingRT = existingEnv.LARK_USER_REFRESH_TOKEN;
   const hasUAT = existingUAT && existingUAT !== 'SETUP_NEEDED' && existingUAT.length > 20;
 
+  // Resolve target client
+  let client = cliArgs.client || null; // 'claude' | 'codex' | 'both' | null (interactive)
+  if (!client && !nonInteractive) {
+    console.log('\n--- Target Client ---');
+    console.log('  1. Claude Code (default)');
+    console.log('  2. Codex');
+    console.log('  3. Both');
+    const choice = (await ask('Choose target [1]: ')).trim();
+    if (choice === '2') client = 'codex';
+    else if (choice === '3') client = 'both';
+    else client = 'claude';
+  }
+  if (!client) client = 'claude';
+
   // Write config
   console.log('\n--- Writing Config ---');
 
@@ -146,8 +161,9 @@ async function main() {
     LARK_USER_REFRESH_TOKEN: hasUAT ? (existingRT || '') : '',
   };
 
-  const result = writeNewConfig(env);
-  console.log(`Written to ${result.configPath} (global)`);
+  const result = writeNewConfig(env, undefined, undefined, client);
+  if (result.configPath) console.log(`Written to ${result.configPath} (Claude Code)`);
+  if (result.codexConfigPath) console.log(`Written to ${result.codexConfigPath} (Codex)`);
 
   // Summary
   console.log('\n' + '='.repeat(60));