xiaozuoassistant 0.1.41

package/dist/server/channels/base-channel.js

@@ -0,0 +1,13 @@
+export class BaseChannel {
+    constructor() {
+        this.messageHandler = null;
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    emitMessage(sessionId, message) {
+        if (this.messageHandler) {
+            this.messageHandler(sessionId, message);
+        }
+    }
+}

package/dist/server/channels/create-channels.js

@@ -0,0 +1,18 @@
+import { TerminalChannel } from './terminal.js';
+import { WebChannel } from './web.js';
+import { TelegramChannel } from './telegram.js';
+import { FeishuChannel } from './feishu.js';
+import { DingTalkChannel } from './dingtalk.js';
+import { WechatChannel } from './wechat.js';
+export function createChannels({ app, io, config, pluginManager }) {
+    const channels = [
+        new TerminalChannel(),
+        new WebChannel(io),
+        ...(config.channels?.telegram?.token ? [new TelegramChannel()] : []),
+        ...(config.channels?.feishu?.appId ? [new FeishuChannel(app)] : []),
+        ...(config.channels?.dingtalk?.clientId ? [new DingTalkChannel(app)] : []),
+        ...(config.channels?.wechat?.enabled ? [new WechatChannel()] : []),
+        ...pluginManager.getChannels()
+    ];
+    return channels;
+}

package/dist/server/channels/dingtalk.js

@@ -0,0 +1,83 @@
+import { BaseChannel } from './base-channel.js';
+import { config } from '../config/loader.js';
+import axios from 'axios';
+export class DingTalkChannel extends BaseChannel {
+    constructor(app) {
+        super();
+        this.app = app;
+        this.name = 'dingtalk';
+        this.accessToken = '';
+        this.tokenExpire = 0;
+        this.clientId = config.channels?.dingtalk?.clientId;
+        this.clientSecret = config.channels?.dingtalk?.clientSecret;
+    }
+    async start() {
+        if (!this.clientId || !this.clientSecret) {
+            console.log('DingTalk credentials not configured, skipping DingTalk channel.');
+            return;
+        }
+        // Register webhook route
+        this.app.post('/api/channels/dingtalk/event', async (req, res) => {
+            // DingTalk sends messages here
+            // Note: Actual implementation depends on DingTalk's specific event format (Stream mode vs HTTP)
+            // For simplicity, we assume standard HTTP callback for enterprise internal apps
+            const { msgtype, text, conversationId, senderId } = req.body;
+            if (msgtype === 'text' && text?.content) {
+                const sessionId = `dingtalk:${conversationId || senderId}`;
+                // Remove @Bot prefix if present
+                const content = text.content.trim();
+                this.emitMessage(sessionId, content);
+            }
+            res.json({ msg: 'success' });
+        });
+        console.log('DingTalk Channel Started (Webhook at /api/channels/dingtalk/event)');
+    }
+    async stop() {
+    }
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpire) {
+            return this.accessToken;
+        }
+        try {
+            const res = await axios.post('https://api.dingtalk.com/v1.0/oauth2/accessToken', {
+                appKey: this.clientId,
+                appSecret: this.clientSecret
+            });
+            if (res.data.accessToken) {
+                this.accessToken = res.data.accessToken;
+                this.tokenExpire = Date.now() + (res.data.expireIn - 60) * 1000;
+                return this.accessToken;
+            }
+            return '';
+        }
+        catch (error) {
+            console.error('Error getting DingTalk token:', error);
+            return '';
+        }
+    }
+    async send(sessionId, message) {
+        if (!sessionId.startsWith('dingtalk:'))
+            return;
+        // For DingTalk, sending back usually requires knowing the conversation ID or using the Robot Webhook if it's a group
+        // This is a simplified implementation for Enterprise Internal Robot
+        const chatId = sessionId.split(':')[1];
+        const token = await this.getAccessToken();
+        if (!token)
+            return;
+        try {
+            await axios.post('https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend', {
+                robotCode: config.channels?.dingtalk?.robotCode,
+                userIds: [chatId], // Assuming sessionId is userId for direct messages
+                msgKey: 'sampleText',
+                msgParam: JSON.stringify({ content: message })
+            }, {
+                headers: {
+                    'x-acs-dingtalk-access-token': token
+                }
+            });
+        }
+        catch (error) {
+            console.error('Failed to send DingTalk message:', error);
+        }
+    }
+}

package/dist/server/channels/feishu.js

@@ -0,0 +1,95 @@
+import { BaseChannel } from './base-channel.js';
+import { config } from '../config/loader.js';
+import axios from 'axios';
+// Note: Feishu requires a public endpoint for Webhooks.
+// In development, you can use ngrok or similar tools.
+// The endpoint will be mounted on the main express app at /api/channels/feishu
+export class FeishuChannel extends BaseChannel {
+    constructor(app) {
+        super();
+        this.app = app;
+        this.name = 'feishu';
+        this.tenantAccessToken = '';
+        this.tokenExpire = 0;
+        this.appId = config.channels?.feishu?.appId;
+        this.appSecret = config.channels?.feishu?.appSecret;
+    }
+    async start() {
+        if (!this.appId || !this.appSecret) {
+            console.log('Feishu credentials not configured, skipping Feishu channel.');
+            return;
+        }
+        // Register webhook route
+        this.app.post('/api/channels/feishu/event', async (req, res) => {
+            const { challenge, type } = req.body;
+            // URL Verification
+            if (type === 'url_verification') {
+                res.json({ challenge });
+                return;
+            }
+            // Handle Message Event (v2.0)
+            if (req.body.header?.event_type === 'im.message.receive_v1') {
+                const event = req.body.event;
+                const message = event.message;
+                const sender = event.sender;
+                // Ignore messages from bots to prevent loops
+                if (sender.sender_type === 'user') {
+                    const content = JSON.parse(message.content).text;
+                    const sessionId = `feishu:${message.chat_id}`; // Use chat_id as session
+                    this.emitMessage(sessionId, content);
+                }
+            }
+            res.json({ msg: 'ok' });
+        });
+        console.log('Feishu Channel Started (Webhook at /api/channels/feishu/event)');
+    }
+    async stop() {
+        // No explicit stop needed for webhook
+    }
+    async getTenantAccessToken() {
+        if (this.tenantAccessToken && Date.now() < this.tokenExpire) {
+            return this.tenantAccessToken;
+        }
+        try {
+            const res = await axios.post('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
+                app_id: this.appId,
+                app_secret: this.appSecret
+            });
+            if (res.data.code === 0) {
+                this.tenantAccessToken = res.data.tenant_access_token;
+                this.tokenExpire = Date.now() + (res.data.expire - 60) * 1000;
+                return this.tenantAccessToken;
+            }
+            else {
+                console.error('Failed to get Feishu access token:', res.data);
+                return '';
+            }
+        }
+        catch (error) {
+            console.error('Error fetching Feishu token:', error);
+            return '';
+        }
+    }
+    async send(sessionId, message) {
+        if (!sessionId.startsWith('feishu:'))
+            return;
+        const chatId = sessionId.split(':')[1];
+        const token = await this.getTenantAccessToken();
+        if (!token)
+            return;
+        try {
+            await axios.post(`https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=chat_id`, {
+                receive_id: chatId,
+                msg_type: 'text',
+                content: JSON.stringify({ text: message })
+            }, {
+                headers: {
+                    Authorization: `Bearer ${token}`
+                }
+            });
+        }
+        catch (error) {
+            console.error(`Failed to send Feishu message to ${chatId}:`, error);
+        }
+    }
+}

package/dist/server/channels/telegram.js

@@ -0,0 +1,53 @@
+import { BaseChannel } from './base-channel.js';
+import { Telegraf } from 'telegraf';
+import { config } from '../config/loader.js';
+export class TelegramChannel extends BaseChannel {
+    constructor() {
+        super(...arguments);
+        this.name = 'telegram';
+        this.bot = null;
+    }
+    async start() {
+        const token = config.channels?.telegram?.token;
+        if (!token) {
+            console.log('Telegram token not configured, skipping Telegram channel.');
+            return;
+        }
+        try {
+            this.bot = new Telegraf(token);
+            this.bot.on('text', (ctx) => {
+                // Use chat ID as session ID for simple mapping
+                const sessionId = `telegram:${ctx.chat.id}`;
+                const message = ctx.message.text;
+                // Emit message to EventBus
+                this.emitMessage(sessionId, message);
+            });
+            // Launch the bot (polling mode)
+            this.bot.launch(() => {
+                console.log('Telegram Channel Started (Polling)');
+            });
+            // Graceful stop
+            process.once('SIGINT', () => this.bot?.stop('SIGINT'));
+            process.once('SIGTERM', () => this.bot?.stop('SIGTERM'));
+        }
+        catch (error) {
+            console.error('Failed to start Telegram channel:', error);
+        }
+    }
+    async stop() {
+        if (this.bot) {
+            this.bot.stop();
+        }
+    }
+    send(sessionId, message) {
+        if (!this.bot)
+            return;
+        // Parse session ID to get chat ID
+        if (sessionId.startsWith('telegram:')) {
+            const chatId = sessionId.split(':')[1];
+            this.bot.telegram.sendMessage(chatId, message).catch(err => {
+                console.error(`Failed to send Telegram message to ${chatId}:`, err);
+            });
+        }
+    }
+}

package/dist/server/channels/terminal.js

@@ -0,0 +1,49 @@
+import readline from 'readline';
+export class TerminalChannel {
+    constructor() {
+        this.name = 'terminal';
+        this.rl = null;
+        this.messageHandler = null;
+        this.currentSessionId = 'terminal-session'; // Simple fixed session for terminal
+    }
+    async start() {
+        if (!process.stdin.isTTY) {
+            console.log('Terminal channel disabled (non-interactive session)');
+            return;
+        }
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: 'xiaozuoAssistant> '
+        });
+        this.rl.prompt();
+        this.rl.on('line', (line) => {
+            const input = line.trim();
+            if (input && this.messageHandler) {
+                this.messageHandler(this.currentSessionId, input);
+            }
+            // Note: prompt will be called after response is received
+        });
+        this.rl.on('close', () => {
+            console.log('Terminal session closed.');
+        });
+        console.log('Terminal Channel Started');
+    }
+    async stop() {
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+    }
+    send(sessionId, message) {
+        if (sessionId === this.currentSessionId) {
+            console.log(message);
+            if (this.rl) {
+                this.rl.prompt();
+            }
+        }
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+}

package/dist/server/channels/web.js

@@ -0,0 +1,45 @@
+export class WebChannel {
+    constructor(io) {
+        this.name = 'web';
+        this.messageHandler = null;
+        this.io = io;
+    }
+    async start() {
+        this.io.on('connection', (socket) => {
+            console.log(`Web client connected: ${socket.id}`);
+            // 当客户端加入会话房间
+            socket.on('join_session', (sessionId) => {
+                socket.join(sessionId);
+                console.log(`Socket ${socket.id} joined session ${sessionId}`);
+            });
+            // 当客户端发送消息
+            socket.on('message', (data) => {
+                console.log(`[WebChannel] Received message from ${data.sessionId}: ${data.content}`);
+                if (this.messageHandler) {
+                    this.messageHandler(data.sessionId, data.content);
+                }
+            });
+            socket.on('disconnect', () => {
+                console.log(`Web client disconnected: ${socket.id}`);
+            });
+        });
+        console.log('Web Channel Started');
+    }
+    async stop() {
+        // Socket.io handles close with the http server, 
+        // but we can disconnect all sockets if needed
+        this.io.disconnectSockets();
+    }
+    send(sessionId, message) {
+        console.log(`[WebChannel] Sending message to ${sessionId}: ${message}`);
+        // 发送消息到特定的会话房间
+        this.io.to(sessionId).emit('message', {
+            role: 'assistant',
+            content: message,
+            timestamp: Date.now()
+        });
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+}

package/dist/server/channels/wechat.js

@@ -0,0 +1,107 @@
+import { WechatyBuilder, ScanStatus } from 'wechaty';
+import qrcodeTerminal from 'qrcode-terminal';
+import { BaseChannel } from './base-channel.js';
+import { config } from '../config/loader.js';
+export class WechatChannel extends BaseChannel {
+    constructor() {
+        super();
+        this.name = 'wechat';
+        this.isReady = false;
+        const options = {
+            name: 'xiaozuo-bot',
+        };
+        if (config.channels?.wechat?.puppet) {
+            options.puppet = config.channels.wechat.puppet;
+        }
+        if (config.channels?.wechat?.token) {
+            options.puppetOptions = {
+                token: config.channels.wechat.token,
+            };
+        }
+        this.bot = WechatyBuilder.build(options);
+    }
+    async start() {
+        this.bot
+            .on('scan', (qrcode, status) => {
+            if (status === ScanStatus.Waiting || status === ScanStatus.Timeout) {
+                console.log(`[WeChat] Scan QR Code to login: ${status}\nhttps://wechaty.js.org/qrcode/${encodeURIComponent(qrcode)}`);
+                qrcodeTerminal.generate(qrcode, { small: true });
+            }
+            else {
+                console.log(`[WeChat] Scan status: ${status}`);
+            }
+        })
+            .on('login', (user) => {
+            console.log(`[WeChat] User ${user} logged in`);
+            this.isReady = true;
+        })
+            .on('message', async (message) => {
+            if (message.self())
+                return;
+            // Only handle text messages for now
+            if (message.type() !== this.bot.Message.Type.Text)
+                return;
+            const room = message.room();
+            const talker = message.talker();
+            const text = message.text();
+            // If in a room, maybe only respond if mentioned?
+            // For simplicity, let's respond to everything in direct messages, 
+            // and only mentions in rooms if possible, or everything for now (can be noisy).
+            // Let's implement mention check for rooms.
+            if (room) {
+                if (await message.mentionSelf()) {
+                    // Remove the mention part from text if needed, or just pass it.
+                    // Wechaty usually keeps the text as is.
+                    // We use room.id as sessionId for room messages
+                    console.log(`[WeChat] Room Message from ${talker.name()} in ${await room.topic()}: ${text}`);
+                    this.emitMessage(room.id, text.replace(/^@\w+\s+/, '')); // Simple strip
+                }
+            }
+            else {
+                // Direct message
+                console.log(`[WeChat] Direct Message from ${talker.name()}: ${text}`);
+                // Use talker.id as sessionId
+                this.emitMessage(talker.id, text);
+            }
+        })
+            .on('logout', (user) => {
+            console.log(`[WeChat] User ${user} logged out`);
+            this.isReady = false;
+        })
+            .on('error', (e) => {
+            console.error('[WeChat] Error:', e);
+        });
+        await this.bot.start();
+        console.log('[WeChat] Bot started');
+    }
+    async stop() {
+        if (this.bot) {
+            await this.bot.stop();
+            console.log('[WeChat] Bot stopped');
+        }
+    }
+    async send(sessionId, message) {
+        if (!this.isReady) {
+            console.warn('[WeChat] Bot not ready, cannot send message');
+            return;
+        }
+        try {
+            // Try to find room first
+            const room = await this.bot.Room.find({ id: sessionId });
+            if (room) {
+                await room.say(message);
+                return;
+            }
+            // Try to find contact
+            const contact = await this.bot.Contact.find({ id: sessionId });
+            if (contact) {
+                await contact.say(message);
+                return;
+            }
+            console.warn(`[WeChat] Could not find contact or room with ID: ${sessionId}`);
+        }
+        catch (error) {
+            console.error(`[WeChat] Failed to send message to ${sessionId}:`, error);
+        }
+    }
+}

package/dist/server/config/loader.js

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+import { SYSTEM_PROMPT } from './prompts.js';
+const configPath = path.resolve(process.cwd(), 'config.json');
+let loadedConfig;
+try {
+    const fileContent = fs.readFileSync(configPath, 'utf-8');
+    loadedConfig = JSON.parse(fileContent);
+    // Set defaults if missing
+    if (!loadedConfig.systemPrompt)
+        loadedConfig.systemPrompt = SYSTEM_PROMPT;
+    if (!loadedConfig.scheduler)
+        loadedConfig.scheduler = { memoryMaintenanceCron: '0 0 * * *' };
+    if (!loadedConfig.workspace)
+        loadedConfig.workspace = process.cwd();
+    // Ensure LLM config exists
+    if (!loadedConfig.llm) {
+        loadedConfig.llm = {
+            provider: 'qwen',
+            apiKey: '',
+            baseURL: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1',
+            model: 'qwen-plus',
+            temperature: 0.7
+        };
+    }
+    else {
+        if (!loadedConfig.llm.apiKey)
+            loadedConfig.llm.apiKey = '';
+    }
+    // Override with env vars if present (optional, but good for security)
+    if (process.env.XIAOZUO_LLM_API_KEY)
+        loadedConfig.llm.apiKey = process.env.XIAOZUO_LLM_API_KEY;
+    // Log the loaded API key (masked)
+    console.log('[Config] API Key Status:', loadedConfig.llm.apiKey ? 'Configured' : 'Not configured (Empty)');
+    console.log('[Config] Base URL:', loadedConfig.llm.baseURL);
+}
+catch (error) {
+    console.warn('Failed to load config.json, creating a new one with defaults');
+    loadedConfig = {
+        server: { port: 3001, host: 'localhost' },
+        llm: {
+            provider: 'qwen',
+            apiKey: '',
+            baseURL: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1',
+            model: 'qwen-plus',
+            temperature: 0.7
+        },
+        logging: { level: 'info' },
+        scheduler: { memoryMaintenanceCron: '0 0 * * *' },
+        workspace: process.cwd(),
+        systemPrompt: SYSTEM_PROMPT
+    };
+    // Auto-create config.json if it doesn't exist
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(loadedConfig, null, 2), 'utf-8');
+        console.log(`[Config] Created new config.json at ${configPath}`);
+    }
+    catch (writeError) {
+        console.error('[Config] Failed to create default config.json', writeError);
+    }
+}
+export const config = loadedConfig;
+export const saveConfig = (newConfig) => {
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2), 'utf-8');
+        // Update memory
+        Object.assign(config, newConfig);
+    }
+    catch (error) {
+        console.error('Failed to save config.json', error);
+        throw error;
+    }
+};

package/dist/server/config/prompts.js

@@ -0,0 +1,12 @@
+export const SYSTEM_PROMPT = `
+你现在是 我的个人AI助手，叫xiaozuoAssistant。
+
+核心规则：
+1. 所有记忆完全本地存储，不上传任何内容到云端。
+2. 默认工作模式：优先使用 office_work 类别的记忆。
+3. 当用户提到 Word、PPT、Excel、汇报、客户、模板、格式、数据整理、邮件等办公相关内容时，**必须先检索相关记忆**，然后再回答。
+4. 如果记忆中有明确偏好，直接应用，不要再次询问。
+5. 风格：专业、简洁、高效，像一个靠谱的行政/助理。
+6. 语言：默认用中文，必要时中英混用（比如函数名、文件名）。
+7. 主动建议：如果用户在处理重复性工作，可以提醒“您上次处理类似内容时用了XX方法，要不要继续沿用？”
+`.trim();

package/dist/server/core/agents/manager.js

@@ -0,0 +1,22 @@
+export class AgentManager {
+    constructor() {
+        this.agents = new Map();
+    }
+    static getInstance() {
+        if (!AgentManager.instance) {
+            AgentManager.instance = new AgentManager();
+        }
+        return AgentManager.instance;
+    }
+    registerAgent(agent) {
+        this.agents.set(agent.name, agent);
+        console.log(`[AgentManager] Registered agent: ${agent.name}`);
+    }
+    getAgent(name) {
+        return this.agents.get(name);
+    }
+    getAllAgents() {
+        return Array.from(this.agents.values());
+    }
+}
+export const agentManager = AgentManager.getInstance();

package/dist/server/core/agents/runtime.js

@@ -0,0 +1,85 @@
+import { config } from '../../config/loader.js';
+import { createOpenAIClient } from '../../llm/openai.js';
+export class AgentRuntime {
+    constructor(options) {
+        this.openai = createOpenAIClient(config.llm);
+        this.name = options.name;
+        this.description = options.description;
+        this.systemPrompt = options.systemPrompt;
+        this.skills = options.skills || [];
+        this.model = options.model || config.llm.model;
+        this.temperature = options.temperature || config.llm.temperature;
+        this.openai = createOpenAIClient(config.llm);
+    }
+    updateConfig() {
+        this.openai = createOpenAIClient(config.llm);
+        this.model = config.llm.model;
+        this.temperature = config.llm.temperature;
+    }
+    getToolsDefinition() {
+        return this.skills.map(skill => skill.toJSON());
+    }
+    async process(history, newMessage, contextPrompt) {
+        const finalSystemPrompt = contextPrompt
+            ? `${this.systemPrompt}\n${contextPrompt}`
+            : this.systemPrompt;
+        const messages = [
+            { role: 'system', content: finalSystemPrompt },
+            ...history.map(m => ({ role: m.role, content: m.content, name: m.name, tool_call_id: m.tool_call_id, tool_calls: m.tool_calls })),
+            { role: 'user', content: newMessage }
+        ];
+        try {
+            console.log(`[Agent:${this.name}] Calling LLM...`);
+            let response = await this.callLLM(messages);
+            let iterations = 0;
+            const MAX_ITERATIONS = 10;
+            while (response.choices[0].message.tool_calls && iterations < MAX_ITERATIONS) {
+                iterations++;
+                const toolCalls = response.choices[0].message.tool_calls;
+                messages.push(response.choices[0].message);
+                for (const toolCall of toolCalls) {
+                    if (toolCall.type !== 'function')
+                        continue;
+                    const functionName = toolCall.function.name;
+                    const functionArgs = JSON.parse(toolCall.function.arguments);
+                    console.log(`[Agent:${this.name}] Executing tool: ${functionName}`);
+                    const skill = this.skills.find(s => s.name === functionName);
+                    let toolResult = '';
+                    if (skill) {
+                        try {
+                            const result = await skill.execute(functionArgs);
+                            toolResult = JSON.stringify(result);
+                        }
+                        catch (error) {
+                            toolResult = JSON.stringify({ error: error.message });
+                        }
+                    }
+                    else {
+                        toolResult = JSON.stringify({ error: 'Tool not found' });
+                    }
+                    messages.push({
+                        role: 'tool',
+                        tool_call_id: toolCall.id,
+                        content: toolResult
+                    });
+                }
+                response = await this.callLLM(messages);
+            }
+            return response.choices[0].message.content || 'No response generated.';
+        }
+        catch (error) {
+            console.error(`[Agent:${this.name}] Error:`, error);
+            return `Error: ${error.message}`;
+        }
+    }
+    async callLLM(messages) {
+        const tools = this.getToolsDefinition();
+        const toolsParam = tools.length > 0 ? tools : undefined;
+        return await this.openai.chat.completions.create({
+            model: this.model,
+            messages: messages,
+            tools: toolsParam,
+            temperature: this.temperature
+        });
+    }
+}