feishu-user-plugin 1.2.0 → 1.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "feishu-user-plugin",
-  "version": "1.2.0",
-  "description": "All-in-one Feishu plugin for Claude Code — send messages as yourself, read chats, manage docs/tables/wiki. 33 tools + 9 skills, 3 auth layers.",
+  "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.",
   "main": "src/index.js",
   "bin": {
     "feishu-user-plugin": "src/cli.js"

package/src/index.js

@@ -272,10 +272,10 @@ const TOOLS = [
   },
   {
     name: 'get_chat_info',
-    description: '[User Identity] Get chat details: name, description, member count, owner.',
+    description: '[Official API + User Identity fallback] Get chat details: name, description, member count, owner. Supports both oc_xxx and numeric chat_id.',
     inputSchema: {
       type: 'object',
-      properties: { chat_id: { type: 'string', description: 'Chat ID' } },
+      properties: { chat_id: { type: 'string', description: 'Chat ID (oc_xxx or numeric)' } },
       required: ['chat_id'],
     },
   },
@@ -421,6 +421,17 @@ const TOOLS = [
   },
 
   // ========== Bitable — Official API ==========
+  {
+    name: 'create_bitable',
+    description: '[Official API] Create a new Bitable (multi-dimensional table) app.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Bitable app name' },
+        folder_id: { type: 'string', description: 'Parent folder token (optional, defaults to root)' },
+      },
+    },
+  },
   {
     name: 'list_bitable_tables',
     description: '[Official API] List all tables in a Bitable app.',
@@ -430,6 +441,23 @@ const TOOLS = [
       required: ['app_token'],
     },
   },
+  {
+    name: 'create_bitable_table',
+    description: '[Official API] Create a new data table in a Bitable app. Optionally define initial fields.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        name: { type: 'string', description: 'Table name' },
+        fields: {
+          type: 'array',
+          description: 'Initial field definitions (optional). Each item: {field_name, type} where type is 1=Text, 2=Number, 3=SingleSelect, 4=MultiSelect, 5=DateTime, 7=Checkbox, 11=User, 13=Phone, 15=URL, 17=Attachment, 18=Link, 20=Formula, 21=DuplexLink, 22=Location, 23=GroupChat, 1001=CreateTime, 1002=ModifiedTime, 1003=Creator, 1004=Modifier',
+          items: { type: 'object' },
+        },
+      },
+      required: ['app_token', 'name'],
+    },
+  },
   {
     name: 'list_bitable_fields',
     description: '[Official API] List all fields (columns) in a Bitable table.',
@@ -442,6 +470,62 @@ const TOOLS = [
       required: ['app_token', 'table_id'],
     },
   },
+  {
+    name: 'create_bitable_field',
+    description: '[Official API] Create a new field (column) in a Bitable table.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        field_name: { type: 'string', description: 'Field display name' },
+        type: { type: 'number', description: 'Field type: 1=Text, 2=Number, 3=SingleSelect, 4=MultiSelect, 5=DateTime, 7=Checkbox, 11=User, 13=Phone, 15=URL, 17=Attachment, 18=Link, 20=Formula, 21=DuplexLink, 22=Location, 23=GroupChat, 1001=CreateTime, 1002=ModifiedTime, 1003=Creator, 1004=Modifier' },
+        property: { type: 'object', description: 'Field-type-specific properties (optional). E.g. for SingleSelect: {options: [{name:"A"},{name:"B"}]}' },
+      },
+      required: ['app_token', 'table_id', 'field_name', 'type'],
+    },
+  },
+  {
+    name: 'update_bitable_field',
+    description: '[Official API] Update an existing field (column) in a Bitable table.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        field_id: { type: 'string', description: 'Field ID to update' },
+        field_name: { type: 'string', description: 'New field name (optional)' },
+        type: { type: 'number', description: 'Field type (REQUIRED by Feishu API, see create_bitable_field for values)' },
+        property: { type: 'object', description: 'Field-type-specific properties (optional)' },
+      },
+      required: ['app_token', 'table_id', 'field_id', 'type'],
+    },
+  },
+  {
+    name: 'delete_bitable_field',
+    description: '[Official API] Delete a field (column) from a Bitable table.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        field_id: { type: 'string', description: 'Field ID to delete' },
+      },
+      required: ['app_token', 'table_id', 'field_id'],
+    },
+  },
+  {
+    name: 'list_bitable_views',
+    description: '[Official API] List all views in a Bitable table.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+      },
+      required: ['app_token', 'table_id'],
+    },
+  },
   {
     name: 'search_bitable_records',
     description: '[Official API] Search/query records in a Bitable table.',
@@ -484,6 +568,58 @@ const TOOLS = [
       required: ['app_token', 'table_id', 'record_id', 'fields'],
     },
   },
+  {
+    name: 'delete_bitable_record',
+    description: '[Official API] Delete a record (row) 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 to delete' },
+      },
+      required: ['app_token', 'table_id', 'record_id'],
+    },
+  },
+  {
+    name: 'batch_create_bitable_records',
+    description: '[Official API] Batch create multiple records (rows) in a Bitable table. Max 500 per call.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        records: { type: 'array', description: 'Array of {fields: {field_name: value}} objects', items: { type: 'object' } },
+      },
+      required: ['app_token', 'table_id', 'records'],
+    },
+  },
+  {
+    name: 'batch_update_bitable_records',
+    description: '[Official API] Batch update multiple records in a Bitable table. Max 500 per call.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        records: { type: 'array', description: 'Array of {record_id, fields: {field_name: value}} objects', items: { type: 'object' } },
+      },
+      required: ['app_token', 'table_id', 'records'],
+    },
+  },
+  {
+    name: 'batch_delete_bitable_records',
+    description: '[Official API] Batch delete multiple records from a Bitable table. Max 500 per call.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        app_token: { type: 'string', description: 'Bitable app token' },
+        table_id: { type: 'string', description: 'Table ID' },
+        record_ids: { type: 'array', description: 'Array of record IDs to delete', items: { type: 'string' } },
+      },
+      required: ['app_token', 'table_id', 'record_ids'],
+    },
+  },
 
   // ========== Wiki — Official API ==========
   {
@@ -677,9 +813,24 @@ async function handleTool(name, args) {
       return text(chatId ? `P2P chat: ${chatId}` : 'Failed to create P2P chat');
     }
     case 'get_chat_info': {
-      const c = await getUserClient();
-      const info = await c.getGroupInfo(args.chat_id);
-      return info ? json(info) : text(`No info for chat ${args.chat_id}`);
+      // Strategy 1: Official API im.chat.get (supports oc_xxx format)
+      if (args.chat_id.startsWith('oc_')) {
+        try {
+          const info = await getOfficialClient().getChatInfo(args.chat_id);
+          return info ? json(info) : text(`No info for chat ${args.chat_id}`);
+        } catch (e) {
+          console.error(`[feishu-user-plugin] Official getChatInfo failed: ${e.message}`);
+        }
+      }
+      // Strategy 2: Protobuf gateway (supports numeric chat_id)
+      try {
+        const c = await getUserClient();
+        const info = await c.getGroupInfo(args.chat_id);
+        if (info) return json(info);
+      } catch (e) {
+        console.error(`[feishu-user-plugin] Protobuf getChatInfo failed: ${e.message}`);
+      }
+      return text(`No info for chat ${args.chat_id}`);
     }
     case 'get_user_info': {
       let n = null;
@@ -807,10 +958,34 @@ async function handleTool(name, args) {
 
     // --- Official API: Bitable ---
 
+    case 'create_bitable': {
+      const r = await getOfficialClient().createBitable(args.name, args.folder_id);
+      return text(`Bitable created: ${r.appToken}${r.url ? `\nURL: ${r.url}` : ''}`);
+    }
     case 'list_bitable_tables':
       return json(await getOfficialClient().listBitableTables(args.app_token));
+    case 'create_bitable_table':
+      return text(`Table created: ${(await getOfficialClient().createBitableTable(args.app_token, args.name, args.fields)).tableId}`);
     case 'list_bitable_fields':
       return json(await getOfficialClient().listBitableFields(args.app_token, args.table_id));
+    case 'create_bitable_field': {
+      const config = { field_name: args.field_name, type: args.type };
+      if (args.property) config.property = args.property;
+      return json(await getOfficialClient().createBitableField(args.app_token, args.table_id, config));
+    }
+    case 'update_bitable_field': {
+      const config = {};
+      if (args.field_name) config.field_name = args.field_name;
+      if (args.type) config.type = args.type;
+      if (args.property) config.property = args.property;
+      return json(await getOfficialClient().updateBitableField(args.app_token, args.table_id, args.field_id, config));
+    }
+    case 'delete_bitable_field': {
+      const r = await getOfficialClient().deleteBitableField(args.app_token, args.table_id, args.field_id);
+      return text(r.deleted ? `Field ${r.fieldId} deleted` : `Field deletion returned deleted=${r.deleted}`);
+    }
+    case 'list_bitable_views':
+      return json(await getOfficialClient().listBitableViews(args.app_token, args.table_id));
     case 'search_bitable_records':
       return json(await getOfficialClient().searchBitableRecords(args.app_token, args.table_id, {
         filter: args.filter, sort: args.sort, pageSize: args.page_size,
@@ -819,6 +994,14 @@ async function handleTool(name, args) {
       return text(`Record created: ${(await getOfficialClient().createBitableRecord(args.app_token, args.table_id, args.fields)).recordId}`);
     case 'update_bitable_record':
       return text(`Record updated: ${(await getOfficialClient().updateBitableRecord(args.app_token, args.table_id, args.record_id, args.fields)).recordId}`);
+    case 'delete_bitable_record':
+      return text(`Record deleted: ${(await getOfficialClient().deleteBitableRecord(args.app_token, args.table_id, args.record_id)).deleted}`);
+    case 'batch_create_bitable_records':
+      return json(await getOfficialClient().batchCreateBitableRecords(args.app_token, args.table_id, args.records));
+    case 'batch_update_bitable_records':
+      return json(await getOfficialClient().batchUpdateBitableRecords(args.app_token, args.table_id, args.records));
+    case 'batch_delete_bitable_records':
+      return json(await getOfficialClient().batchDeleteBitableRecords(args.app_token, args.table_id, args.record_ids));
 
     // --- Official API: Wiki ---
 

package/src/official.js

@@ -187,7 +187,10 @@ class LarkOfficialClient {
       }),
       'uploadImage'
     );
-    return { imageKey: res.data.image_key };
+    // SDK multipart responses may have data at top level or nested under .data
+    const imageKey = res.data?.image_key || res.image_key;
+    if (!imageKey) throw new Error(`uploadImage: unexpected response structure: ${JSON.stringify(res).slice(0, 500)}`);
+    return { imageKey };
   }
 
   async uploadFile(filePath, fileType = 'stream', fileName) {
@@ -204,7 +207,10 @@ class LarkOfficialClient {
       }),
       'uploadFile'
     );
-    return { fileKey: res.data.file_key };
+    // SDK multipart responses may have data at top level or nested under .data
+    const fileKey = res.data?.file_key || res.file_key;
+    if (!fileKey) throw new Error(`uploadFile: unexpected response structure: ${JSON.stringify(res).slice(0, 500)}`);
+    return { fileKey };
   }
 
   // --- Docs ---
@@ -244,18 +250,74 @@ class LarkOfficialClient {
     return { items: res.data.items || [] };
   }
 
+  // --- Chat Info (Official API) ---
+
+  async getChatInfo(chatId) {
+    const res = await this._safeSDKCall(
+      () => this.client.im.chat.get({ path: { chat_id: chatId } }),
+      'getChatInfo'
+    );
+    return res.data;
+  }
+
   // --- Bitable ---
 
+  async createBitable(name, folderId) {
+    const data = {};
+    if (name) data.name = name;
+    if (folderId) data.folder_token = folderId;
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.app.create({ data }),
+      'createBitable'
+    );
+    return { appToken: res.data.app?.app_token, name: res.data.app?.name, url: res.data.app?.url };
+  }
+
   async listBitableTables(appToken) {
     const res = await this._safeSDKCall(() => this.client.bitable.appTable.list({ path: { app_token: appToken } }), 'listTables');
     return { items: res.data.items || [] };
   }
 
+  async createBitableTable(appToken, name, fields) {
+    const data = { table: { name } };
+    if (fields && fields.length > 0) data.table.default_view_name = name;
+    if (fields && fields.length > 0) data.table.fields = fields;
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTable.create({ path: { app_token: appToken }, data }),
+      'createTable'
+    );
+    return { tableId: res.data.table_id };
+  }
+
   async listBitableFields(appToken, tableId) {
     const res = await this._safeSDKCall(() => this.client.bitable.appTableField.list({ path: { app_token: appToken, table_id: tableId } }), 'listFields');
     return { items: res.data.items || [] };
   }
 
+  async createBitableField(appToken, tableId, fieldConfig) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableField.create({ path: { app_token: appToken, table_id: tableId }, data: fieldConfig }),
+      'createField'
+    );
+    return { field: res.data.field };
+  }
+
+  async updateBitableField(appToken, tableId, fieldId, fieldConfig) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableField.update({ path: { app_token: appToken, table_id: tableId, field_id: fieldId }, data: fieldConfig }),
+      'updateField'
+    );
+    return { field: res.data.field };
+  }
+
+  async deleteBitableField(appToken, tableId, fieldId) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableField.delete({ path: { app_token: appToken, table_id: tableId, field_id: fieldId } }),
+      'deleteField'
+    );
+    return { fieldId: res.data.field_id, deleted: res.data.deleted };
+  }
+
   async searchBitableRecords(appToken, tableId, { filter, sort, pageSize = 20, pageToken } = {}) {
     const data = {};
     if (filter) data.filter = filter;
@@ -285,6 +347,46 @@ class LarkOfficialClient {
     return { recordId: res.data.record?.record_id };
   }
 
+  async deleteBitableRecord(appToken, tableId, recordId) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableRecord.delete({ path: { app_token: appToken, table_id: tableId, record_id: recordId } }),
+      'deleteRecord'
+    );
+    return { deleted: res.data.deleted };
+  }
+
+  async batchCreateBitableRecords(appToken, tableId, records) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableRecord.batchCreate({ path: { app_token: appToken, table_id: tableId }, data: { records } }),
+      'batchCreateRecords'
+    );
+    return { records: res.data.records || [] };
+  }
+
+  async batchUpdateBitableRecords(appToken, tableId, records) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableRecord.batchUpdate({ path: { app_token: appToken, table_id: tableId }, data: { records } }),
+      'batchUpdateRecords'
+    );
+    return { records: res.data.records || [] };
+  }
+
+  async batchDeleteBitableRecords(appToken, tableId, recordIds) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableRecord.batchDelete({ path: { app_token: appToken, table_id: tableId }, data: { records: recordIds } }),
+      'batchDeleteRecords'
+    );
+    return { records: res.data.records || [] };
+  }
+
+  async listBitableViews(appToken, tableId) {
+    const res = await this._safeSDKCall(
+      () => this.client.bitable.appTableView.list({ path: { app_token: appToken, table_id: tableId }, params: { page_size: 50 } }),
+      'listViews'
+    );
+    return { items: res.data.items || [] };
+  }
+
   // --- Wiki ---
 
   async listWikiSpaces() {
@@ -369,7 +471,9 @@ class LarkOfficialClient {
   async _safeSDKCall(fn, label = 'API') {
     try {
       const res = await fn();
-      if (res.code !== 0) throw new Error(`${label} failed (${res.code}): ${res.msg}`);
+      // SDK returns abbreviated responses for multipart uploads (code/msg undefined)
+      // Only treat as error if code is explicitly non-zero
+      if (res.code !== undefined && res.code !== 0) throw new Error(`${label} failed (${res.code}): ${res.msg}`);
       return res;
     } catch (err) {
       // Lark SDK uses axios; extract actual Feishu error from response body