xiaozuoassistant 0.2.46 → 0.2.48

package/dist/server/plugins/lark-skills/src/index.js

@@ -0,0 +1,15 @@
+import { ReadLarkDocSkill, CreateLarkDocSkill, AppendLarkDocSkill } from './lark-doc.js';
+const plugin = {
+    metadata: {
+        name: 'lark-skills',
+        version: '1.0.0',
+        description: 'Lark suite integration skills (Docs, Sheets, etc.)',
+        author: 'XiaoZuoClaw Team'
+    },
+    onLoad: (context) => {
+        context.registerSkill(new ReadLarkDocSkill());
+        context.registerSkill(new CreateLarkDocSkill());
+        context.registerSkill(new AppendLarkDocSkill());
+    }
+};
+export default plugin;

package/dist/server/plugins/lark-skills/src/lark-doc.js

@@ -0,0 +1,251 @@
+import { BaseSkill } from '../../../skills/base-skill.js';
+import * as lark from '@larksuiteoapi/node-sdk';
+export class ReadLarkDocSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'read_lark_doc';
+        this.description = 'Read text content from a Lark/Feishu document using its URL or token';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                document_url: {
+                    type: 'string',
+                    description: 'The URL or token of the Lark/Feishu document to read'
+                },
+                app_id: {
+                    type: 'string',
+                    description: 'The Lark App ID to use for authentication (optional, defaults to the first configured Feishu bot)'
+                },
+                app_secret: {
+                    type: 'string',
+                    description: 'The Lark App Secret to use for authentication (optional, defaults to the first configured Feishu bot)'
+                }
+            },
+            required: ['document_url']
+        };
+    }
+    async execute(args, ctx) {
+        try {
+            // Extract document token from URL
+            // Typical Lark doc URL formats:
+            // https://domain.feishu.cn/docx/TOKEN
+            // https://domain.feishu.cn/wiki/WIKITOKEN
+            let documentToken = args.document_url;
+            // Basic extraction logic
+            if (args.document_url.includes('/docx/')) {
+                documentToken = args.document_url.split('/docx/')[1].split(/[?#]/)[0];
+            }
+            else if (args.document_url.includes('/doc/')) {
+                documentToken = args.document_url.split('/doc/')[1].split(/[?#]/)[0];
+            }
+            // Fetch config to get app_id and app_secret if not provided
+            const configLoader = require('../../../config/loader.js').config;
+            let appId = args.app_id;
+            let appSecret = args.app_secret;
+            if (!appId || !appSecret) {
+                const feishuBots = configLoader.channels?.feishu;
+                if (feishuBots && Array.isArray(feishuBots) && feishuBots.length > 0) {
+                    // If context has botName, try to find that specific bot
+                    if (ctx?.metadata?.botName) {
+                        const specificBot = feishuBots.find((b) => b.name === ctx.metadata.botName);
+                        if (specificBot) {
+                            appId = specificBot.appId;
+                            appSecret = specificBot.appSecret;
+                        }
+                    }
+                    // Fallback to first bot
+                    if (!appId || !appSecret) {
+                        appId = feishuBots[0].appId;
+                        appSecret = feishuBots[0].appSecret;
+                    }
+                }
+                else {
+                    return { error: 'Lark App ID and Secret are required to read documents. Please configure a Feishu bot or provide them in the arguments.' };
+                }
+            }
+            const client = new lark.Client({
+                appId: appId,
+                appSecret: appSecret,
+            });
+            // We use the drive/v1/export API or docx/v1/documents API to read content
+            // Let's try the newer DOCX API first to get raw content
+            const res = await client.docx.document.rawContent({
+                path: {
+                    document_id: documentToken,
+                },
+            });
+            if (res.code !== 0) {
+                return { error: `Failed to read Lark document. Code: ${res.code}, Msg: ${res.msg}. Make sure the App has the "docs:doc:readonly" permission and has been added as a collaborator to the document.` };
+            }
+            return {
+                success: true,
+                content: res.data?.content || "No content returned."
+            };
+        }
+        catch (error) {
+            return { error: `Failed to read Lark document: ${error.message}. Ensure the token is correct and the App has appropriate permissions.` };
+        }
+    }
+}
+export class CreateLarkDocSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'create_lark_doc';
+        this.description = 'Create a new Lark/Feishu document (docx)';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Title of the new document'
+                },
+                folder_token: {
+                    type: 'string',
+                    description: 'Optional folder token to create the document in'
+                },
+                app_id: {
+                    type: 'string',
+                    description: 'The Lark App ID (optional, defaults to configured bot)'
+                },
+                app_secret: {
+                    type: 'string',
+                    description: 'The Lark App Secret (optional)'
+                }
+            },
+            required: ['title']
+        };
+    }
+    async execute(args, ctx) {
+        try {
+            const configLoader = require('../../../config/loader.js').config;
+            let appId = args.app_id;
+            let appSecret = args.app_secret;
+            if (!appId || !appSecret) {
+                const feishuBots = configLoader.channels?.feishu;
+                if (feishuBots && Array.isArray(feishuBots) && feishuBots.length > 0) {
+                    if (ctx?.metadata?.botName) {
+                        const specificBot = feishuBots.find((b) => b.name === ctx.metadata.botName);
+                        if (specificBot) {
+                            appId = specificBot.appId;
+                            appSecret = specificBot.appSecret;
+                        }
+                    }
+                    if (!appId || !appSecret) {
+                        appId = feishuBots[0].appId;
+                        appSecret = feishuBots[0].appSecret;
+                    }
+                }
+                else {
+                    return { error: 'Lark App ID and Secret are required.' };
+                }
+            }
+            const client = new lark.Client({ appId: appId, appSecret: appSecret });
+            const res = await client.docx.document.create({
+                data: {
+                    title: args.title,
+                    folder_token: args.folder_token || ''
+                }
+            });
+            if (res.code !== 0) {
+                return { error: `Failed to create document. Code: ${res.code}, Msg: ${res.msg}` };
+            }
+            const docId = res.data?.document?.document_id;
+            return {
+                success: true,
+                document_id: docId,
+                url: `https://${client.domain || 'feishu.cn'}/docx/${docId}`
+            };
+        }
+        catch (error) {
+            return { error: `Failed to create document: ${error.message}` };
+        }
+    }
+}
+export class AppendLarkDocSkill extends BaseSkill {
+    constructor() {
+        super(...arguments);
+        this.name = 'append_lark_doc';
+        this.description = 'Append text content to an existing Lark/Feishu document (docx)';
+        this.parameters = {
+            type: 'object',
+            properties: {
+                document_url: {
+                    type: 'string',
+                    description: 'The URL or token of the document to append to'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The text content to append'
+                },
+                app_id: { type: 'string' },
+                app_secret: { type: 'string' }
+            },
+            required: ['document_url', 'content']
+        };
+    }
+    async execute(args, ctx) {
+        try {
+            let documentToken = args.document_url;
+            if (args.document_url.includes('/docx/')) {
+                documentToken = args.document_url.split('/docx/')[1].split(/[?#]/)[0];
+            }
+            else if (args.document_url.includes('/doc/')) {
+                documentToken = args.document_url.split('/doc/')[1].split(/[?#]/)[0];
+            }
+            const configLoader = require('../../../config/loader.js').config;
+            let appId = args.app_id;
+            let appSecret = args.app_secret;
+            if (!appId || !appSecret) {
+                const feishuBots = configLoader.channels?.feishu;
+                if (feishuBots && Array.isArray(feishuBots) && feishuBots.length > 0) {
+                    if (ctx?.metadata?.botName) {
+                        const specificBot = feishuBots.find((b) => b.name === ctx.metadata.botName);
+                        if (specificBot) {
+                            appId = specificBot.appId;
+                            appSecret = specificBot.appSecret;
+                        }
+                    }
+                    if (!appId || !appSecret) {
+                        appId = feishuBots[0].appId;
+                        appSecret = feishuBots[0].appSecret;
+                    }
+                }
+                else {
+                    return { error: 'Lark App ID and Secret are required.' };
+                }
+            }
+            const client = new lark.Client({ appId: appId, appSecret: appSecret });
+            // Create blocks from content
+            const lines = args.content.split('\n').filter(l => l.trim() !== '');
+            const children = lines.map(line => ({
+                block_type: 2, // Text block
+                text: {
+                    elements: [
+                        {
+                            text_run: { content: line }
+                        }
+                    ]
+                }
+            }));
+            if (children.length === 0)
+                return { success: true, message: 'Nothing to append' };
+            const res = await client.docx.documentBlockChildren.create({
+                path: {
+                    document_id: documentToken,
+                    block_id: documentToken
+                },
+                data: {
+                    children: children,
+                    index: -1
+                }
+            });
+            if (res.code !== 0) {
+                return { error: `Failed to append to document. Code: ${res.code}, Msg: ${res.msg}` };
+            }
+            return { success: true, message: 'Content appended successfully' };
+        }
+        catch (error) {
+            return { error: `Failed to append to document: ${error.message}` };
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xiaozuoassistant",
-  "version": "0.2.46",
+  "version": "0.2.48",
   "description": "A local-first personal AI assistant with multi-channel support and enhanced memory.",
   "author": "mantle.lau",
   "license": "MIT",