xiaozuoassistant 0.2.19 → 0.2.21

package/dist/server/index.js

@@ -0,0 +1,878 @@
+import { overrideConsole } from './core/logger.js'; // Import logger override
+import express from 'express';
+// Initialize logger override immediately to capture all logs
+overrideConsole();
+import { config, saveConfig } from './config/loader.js';
+import { eventBus } from './core/event-bus.js';
+import { brain } from './core/brain.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs'; // Ensure fs is imported for sync operations like existsSync
+import fsPromises from 'fs/promises'; // For async file operations if needed
+import crypto from 'crypto';
+import axios from 'axios';
+import { memory } from './core/memory.js';
+import { PluginManager } from './core/plugin-manager.js';
+import { initScheduler, runMaintenanceNow, getSchedulerStatus, startScheduler, stopScheduler } from './core/scheduler.js';
+import { agentManager } from './core/agents/manager.js';
+import { createOfficeAgent } from './agents/office.js';
+import { createChannels } from './channels/create-channels.js';
+import { createHttpStack } from './server/create-http.js';
+import { taskQueue } from './core/task-queue.js';
+import { WebChannel } from './channels/web.js';
+// 解决 ES Module 中没有 __dirname 的问题
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const { app, httpServer, io } = createHttpStack();
+// Request logging middleware
+app.use((req, res, next) => {
+    console.log(`[HTTP] ${req.method} ${req.url}`);
+    next();
+});
+// 静态文件服务
+// 在生产环境中（dist/server/index.js），客户端构建文件通常位于 ../../dist/client 或 ../client
+// 我们假设构建结构如下：
+// dist/
+//   server/
+//     index.js
+//   client/
+//     index.html
+//     assets/
+//
+// 这样在 server/index.js 中，客户端路径应该是 path.join(__dirname, '../client')
+const clientBuildPath = path.join(__dirname, '../client');
+console.log(`[Server] Serving static files from: ${clientBuildPath}`);
+// 或者在开发模式下，可能是不同的路径，但开发模式通常用 Vite 代理，所以这里主要关注生产环境。
+app.use(express.static(clientBuildPath));
+// API 路由
+// ... existing routes ...
+// 前端路由回退处理 (SPA 支持)
+// 必须放在所有 API 路由之后
+app.get('*', (req, res, next) => {
+    // 如果是 API 请求，跳过
+    if (req.path.startsWith('/api')) {
+        return next();
+    }
+    const indexPath = path.join(clientBuildPath, 'index.html');
+    if (fs.existsSync(indexPath)) { // 这里需要确保 fs 已导入，或者用 fs.access
+        res.sendFile(indexPath);
+    }
+    else {
+        // 如果找不到 index.html（例如开发模式只启动了后端），则返回简单的提示
+        res.send('xiaozuoAssistant backend is running. Frontend static files not found in ' + clientBuildPath);
+    }
+});
+// ... rest of the file ...
+// API 路由
+app.get('/api/health', (req, res) => {
+    res.json({ status: 'ok', message: 'xiaozuoAssistant backend is running' });
+});
+// 获取所有会话
+app.get('/api/sessions', async (req, res) => {
+    try {
+        const sessions = await memory.listSessions();
+        res.json(sessions);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// 获取会话详情
+app.get('/api/sessions/:id', async (req, res) => {
+    try {
+        const session = await memory.getSession(req.params.id);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.json(session);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// 创建新会话
+app.post('/api/sessions', async (req, res) => {
+    try {
+        const { alias, workspace } = req.body || {};
+        const session = await memory.createSession({ alias, workspace });
+        res.json(session.meta);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// 追加一条消息到会话（用于欢迎语/系统消息等）
+app.post('/api/sessions/:id/messages', async (req, res) => {
+    try {
+        const role = String(req.body?.role || '').trim();
+        const content = String(req.body?.content || '');
+        const timestamp = req.body?.timestamp;
+        const name = req.body?.name;
+        if (!['system', 'user', 'assistant', 'tool'].includes(role)) {
+            res.status(400).json({ error: 'Invalid role' });
+            return;
+        }
+        if (!content.trim()) {
+            res.status(400).json({ error: 'Content cannot be empty' });
+            return;
+        }
+        await memory.addMessage(req.params.id, {
+            role: role,
+            content,
+            ...(timestamp ? { timestamp: Number(timestamp) } : {}),
+            ...(name ? { name: String(name) } : {})
+        });
+        res.json({ status: 'success' });
+    }
+    catch (e) {
+        const msg = String(e?.message || 'Unknown error');
+        if (msg.toLowerCase().includes('not found')) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+// 更新会话元信息
+app.patch('/api/sessions/:id', async (req, res) => {
+    try {
+        const { alias, workspace, context, projectId, projectIds, notebookId } = req.body || {};
+        const meta = await memory.updateSessionMeta(req.params.id, {
+            alias,
+            workspace,
+            context,
+            projectId: projectId || null,
+            projectIds: projectIds || null,
+            notebookId: notebookId || null
+        });
+        res.json(meta);
+    }
+    catch (e) {
+        const msg = String(e?.message || 'Unknown error');
+        if (msg.toLowerCase().includes('not found')) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+// 手动持久化会话（刷新 updatedAt，并确保会话数据文件存在）
+app.post('/api/sessions/:id/persist', async (req, res) => {
+    try {
+        const meta = await memory.persistSession(req.params.id);
+        res.json(meta);
+    }
+    catch (e) {
+        const msg = String(e?.message || 'Unknown error');
+        if (msg.toLowerCase().includes('not found')) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+// 重置会话消息
+app.post('/api/sessions/:id/reset', async (req, res) => {
+    try {
+        await memory.clearSessionMessages(req.params.id);
+        res.json({ status: 'success' });
+    }
+    catch (e) {
+        const msg = String(e?.message || 'Unknown error');
+        if (msg.toLowerCase().includes('not found')) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+// 删除会话
+app.delete('/api/sessions/:id', async (req, res) => {
+    try {
+        await memory.deleteSession(req.params.id);
+        res.json({ status: 'success', message: 'Session deleted' });
+    }
+    catch (e) {
+        const msg = String(e?.message || 'Unknown error');
+        if (msg.toLowerCase().includes('not found')) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+// 文件选择接口 (使用系统默认文件对话框可能需要Electron，这里作为Web服务，我们提供目录列表供选择)
+// 简单的目录列举接口
+app.post('/api/fs/list', async (req, res) => {
+    try {
+        const dirPath = req.body.path || process.cwd();
+        // Use fsPromises for async operations which returns proper types for withFileTypes
+        const items = await fsPromises.readdir(dirPath, { withFileTypes: true });
+        const result = items.map(item => ({
+            name: item.name,
+            isDirectory: item.isDirectory(),
+            path: path.join(dirPath, item.name)
+        })).filter(item => item.isDirectory && !item.name.startsWith('.')); // 仅列出目录，忽略隐藏目录
+        res.json({
+            current: dirPath,
+            parent: path.dirname(dirPath),
+            items: result
+        });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// 获取当前配置
+app.get('/api/config', async (req, res) => {
+    res.json({
+        userId: config.userId,
+        apiKey: config.llm.apiKey,
+        baseURL: config.llm.baseURL,
+        model: config.llm.model,
+        embeddingModel: config.llm.embeddingModel,
+        temperature: config.llm.temperature,
+        maxHistoryMessages: config.llm.maxHistoryMessages,
+        maxToolIterations: config.llm.maxToolIterations,
+        systemPrompt: config.systemPrompt,
+        memoryMaintenanceCron: config.scheduler?.memoryMaintenanceCron,
+        sessionRetentionDays: config.scheduler?.sessionRetentionDays,
+        workspace: config.workspace,
+        feishuAppId: Array.isArray(config.channels?.feishu) ? config.channels?.feishu[0]?.appId : config.channels?.feishu?.appId || '',
+        feishuAppSecret: Array.isArray(config.channels?.feishu) ? config.channels?.feishu[0]?.appSecret : config.channels?.feishu?.appSecret || '',
+        feishu: config.channels?.feishu || []
+    });
+});
+// 更新配置并写入 config.json
+app.post('/api/config', async (req, res) => {
+    try {
+        const { userId, apiKey, baseURL, model, embeddingModel, temperature, systemPrompt, memoryMaintenanceCron, sessionRetentionDays, workspace, maxHistoryMessages, maxToolIterations, feishu, feishuAppId, feishuAppSecret } = req.body;
+        // 更新配置对象
+        const newConfig = { ...config };
+        if (userId !== undefined)
+            newConfig.userId = String(userId || 'default').trim() || 'default';
+        if (apiKey !== undefined)
+            newConfig.llm.apiKey = apiKey;
+        if (baseURL !== undefined)
+            newConfig.llm.baseURL = baseURL;
+        if (model !== undefined)
+            newConfig.llm.model = model;
+        if (embeddingModel !== undefined)
+            newConfig.llm.embeddingModel = embeddingModel;
+        if (temperature !== undefined)
+            newConfig.llm.temperature = parseFloat(temperature);
+        if (maxHistoryMessages !== undefined)
+            newConfig.llm.maxHistoryMessages = parseInt(maxHistoryMessages, 10);
+        if (maxToolIterations !== undefined)
+            newConfig.llm.maxToolIterations = parseInt(maxToolIterations, 10);
+        if (systemPrompt !== undefined)
+            newConfig.systemPrompt = systemPrompt;
+        if (workspace !== undefined)
+            newConfig.workspace = workspace;
+        if (feishu !== undefined) {
+            if (!newConfig.channels)
+                newConfig.channels = {};
+            newConfig.channels.feishu = feishu;
+        }
+        else if (feishuAppId !== undefined || feishuAppSecret !== undefined) {
+            if (!newConfig.channels)
+                newConfig.channels = {};
+            const currentFeishu = newConfig.channels.feishu;
+            const firstBot = Array.isArray(currentFeishu)
+                ? (currentFeishu[0] || { name: 'default', appId: '', appSecret: '' })
+                : { name: 'default', appId: currentFeishu?.appId || '', appSecret: currentFeishu?.appSecret || '' };
+            newConfig.channels.feishu = [{
+                    ...firstBot,
+                    name: firstBot.name || 'default',
+                    appId: feishuAppId !== undefined ? feishuAppId : firstBot.appId,
+                    appSecret: feishuAppSecret !== undefined ? feishuAppSecret : firstBot.appSecret
+                }];
+        }
+        // System prompt is fully controlled by the UI (identity + base prompt).
+        let restartScheduler = false;
+        if (memoryMaintenanceCron !== undefined) {
+            if (!newConfig.scheduler)
+                newConfig.scheduler = {};
+            if (newConfig.scheduler.memoryMaintenanceCron !== memoryMaintenanceCron) {
+                newConfig.scheduler.memoryMaintenanceCron = memoryMaintenanceCron;
+                restartScheduler = true;
+            }
+        }
+        if (sessionRetentionDays !== undefined) {
+            if (!newConfig.scheduler)
+                newConfig.scheduler = {};
+            const days = Number(sessionRetentionDays);
+            if (Number.isFinite(days) && days > 0 && newConfig.scheduler.sessionRetentionDays !== days) {
+                newConfig.scheduler.sessionRetentionDays = days;
+                restartScheduler = true;
+            }
+        }
+        // 保存到文件
+        saveConfig(newConfig);
+        // 如果 LLM 配置变了，更新 Brain
+        brain.updateClient();
+        // 同步更新所有 Agent 与向量记忆客户端（否则仍会用旧 apiKey）
+        agentManager.updateAllConfigs();
+        memory.updateClients();
+        // 如果定时任务配置变了，重启 Scheduler
+        if (restartScheduler) {
+            initScheduler();
+        }
+        // 如果飞书配置变了，尝试重启或启动飞书通道
+        if (feishu !== undefined || feishuAppId !== undefined || feishuAppSecret !== undefined) {
+            const existingFeishu = channels.find(c => c.name === 'feishu');
+            if (existingFeishu) {
+                // Restart existing channel
+                await existingFeishu.stop();
+                await existingFeishu.start();
+            }
+            else if (newConfig.channels?.feishu && Array.isArray(newConfig.channels.feishu) && newConfig.channels.feishu.length > 0) {
+                // Start new channel if it wasn't running
+                const { FeishuChannel } = await import('./channels/feishu.js');
+                const feishuChannel = new FeishuChannel();
+                channels.push(feishuChannel);
+                await feishuChannel.start();
+                feishuChannel.onMessage((sessionId, message) => {
+                    eventBus.emitEvent({
+                        type: 'message',
+                        payload: { content: message },
+                        channel: feishuChannel.name,
+                        sessionId: sessionId,
+                        timestamp: Date.now()
+                    });
+                });
+            }
+        }
+        res.json({ status: 'success', message: 'Config updated and saved to config.json' });
+    }
+    catch (error) {
+        res.status(500).json({ status: 'error', message: error.message });
+    }
+});
+app.get('/api/user/profile', async (req, res) => {
+    try {
+        const userId = String(req.query.userId || config.userId || 'default');
+        const profile = memory.getUserProfile(userId);
+        res.json({ userId, profile });
+    }
+    catch (e) {
+        res.status(500).json({ error: String(e?.message || e) });
+    }
+});
+app.post('/api/user/profile', async (req, res) => {
+    try {
+        const userId = String(req.body?.userId || config.userId || 'default');
+        const profile = req.body?.profile || {};
+        memory.updateUserProfile(userId, profile);
+        res.json({ status: 'success' });
+    }
+    catch (e) {
+        res.status(500).json({ error: String(e?.message || e) });
+    }
+});
+// 手动触发记忆归档
+app.post('/api/sessions/:id/archive', async (req, res) => {
+    try {
+        const sessionId = req.params.id;
+        const session = await memory.getSession(sessionId);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        // 强制触发一次归档逻辑，忽略时间间隔检查
+        // 我们复用 MemoryManager 的 runSessionArchiving，但需要它支持指定 session
+        // 或者我们在这里手动调用类似的逻辑，为了复用，建议在 MemoryManager 中公开一个 archiveSession 方法
+        // 由于 MemoryManager.runSessionArchiving 是批量处理，我们暂时修改 MemoryManager 来支持单个 Session 归档
+        // 或者简单地，我们在 index.ts 里调用 memory.runSessionArchiving()，它会扫描所有 session，
+        // 但为了强制归档，我们需要重置 lastArchivedAt 为 0 (或者很久以前)
+        // 方案：先更新 lastArchivedAt 为 0，然后调用 runSessionArchiving
+        await memory.updateSessionMeta(sessionId, { lastArchivedAt: 0 });
+        await memory.runSessionArchiving();
+        res.json({ status: 'success', message: 'Session archived successfully.' });
+    }
+    catch (e) {
+        res.status(500).json({ status: 'error', message: e.message });
+    }
+});
+// 获取定时任务状态
+app.get('/api/scheduler/status', (req, res) => {
+    res.json(getSchedulerStatus());
+});
+// 启动定时任务
+app.post('/api/scheduler/start', (req, res) => {
+    startScheduler();
+    res.json({ status: 'success', message: 'Scheduler started.', data: getSchedulerStatus() });
+});
+// 停止定时任务
+app.post('/api/scheduler/stop', (req, res) => {
+    stopScheduler();
+    res.json({ status: 'success', message: 'Scheduler stopped.', data: getSchedulerStatus() });
+});
+// 手动触发记忆维护
+app.post('/api/scheduler/run', async (req, res) => {
+    try {
+        await runMaintenanceNow();
+        res.json({ status: 'success', message: 'Memory maintenance completed.' });
+    }
+    catch (e) {
+        res.status(500).json({ status: 'error', message: e.message });
+    }
+});
+// 预设第三方插件的元数据
+const thirdPartySkillsMeta = {
+    'wps_office': {
+        id: 'wps_office',
+        name: 'WPS Office 办公助手',
+        description: '授权 AI 读取和编辑本地 WPS 文档、表格和演示文稿。',
+        enabled: false,
+        isBuiltIn: false
+    },
+    'lark_docs': {
+        id: 'lark_docs',
+        name: '飞书文档 (Lark Docs) 助手',
+        description: '授权 AI 读取您的飞书云文档知识库，并在对话中进行总结和答疑。',
+        enabled: false,
+        isBuiltIn: false
+    }
+};
+app.get('/api/plugins', (req, res) => {
+    try {
+        const plugins = pluginManager.getPlugins();
+        // Merge with third-party auth state (WPS/Lark)
+        // Todo: This should be handled by the plugin system itself
+        const enhancedPlugins = plugins.map(p => {
+            if (p.name === 'wps_office') {
+                return { ...p, enabled: thirdPartySkillsMeta.wps_office.enabled };
+            }
+            if (p.name === 'lark_docs') {
+                return { ...p, enabled: thirdPartySkillsMeta.lark_docs.enabled };
+            }
+            return p;
+        });
+        // Add pending third-party plugins if not loaded yet
+        if (!enhancedPlugins.find(p => p.name === 'wps_office')) {
+            enhancedPlugins.push(thirdPartySkillsMeta.wps_office);
+        }
+        if (!enhancedPlugins.find(p => p.name === 'lark_docs')) {
+            enhancedPlugins.push(thirdPartySkillsMeta.lark_docs);
+        }
+        res.json(enhancedPlugins);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// 存储 OAuth 状态以防止 CSRF 攻击
+const oauthStates = new Map();
+// 模拟的 Token 存储 (实际应存入 SQLite 或加密文件)
+const oauthTokens = new Map();
+// Mock OAuth 授权接口
+app.get('/api/auth/:provider/authorize', (req, res) => {
+    const provider = req.params.provider;
+    const state = crypto.randomBytes(16).toString('hex');
+    oauthStates.set(state, { provider, expiresAt: Date.now() + 10 * 60 * 1000 });
+    let authUrl = '';
+    // 使用相对路径或动态获取 host，这里使用 req.get('host') 自动适配当前后端运行的端口
+    const protocol = req.protocol || 'http';
+    const host = req.get('host') || 'localhost:3001';
+    const redirectUri = encodeURIComponent(`${protocol}://${host}/api/auth/${provider}/callback`);
+    if (provider === 'lark') {
+        const firstFeishuBot = config.channels?.feishu?.[0];
+        const appId = firstFeishuBot?.appId;
+        const appSecret = firstFeishuBot?.appSecret;
+        if (!appId || !appSecret) {
+            return res.status(500).send('Feishu credentials not configured');
+        }
+        authUrl = `https://open.feishu.cn/open-apis/authen/v1/user_auth_page_beta?app_id=${appId}&redirect_uri=${redirectUri}&state=${state}`;
+    }
+    else if (provider === 'wps') {
+        // WPS OAuth 2.0 文档参考：https://open.wps.cn/docs/office/auth
+        const appId = process.env.WPS_APP_ID || ''; // 需要在 WPS 开放平台申请
+        authUrl = `https://openapi.wps.cn/oauthapi/v2/authorize?response_type=code&app_id=${appId}&redirect_uri=${redirectUri}&state=${state}`;
+    }
+    else {
+        return res.status(400).send('Unsupported provider');
+    }
+    res.redirect(authUrl);
+});
+// OAuth 回调接口 (处理真实的 Code 换 Token)
+app.get('/api/auth/:provider/callback', async (req, res) => {
+    const provider = req.params.provider;
+    const { code, state } = req.query;
+    if (!code || !state) {
+        return res.status(400).send('Missing code or state');
+    }
+    // 验证 State
+    const stateData = oauthStates.get(state);
+    if (!stateData || stateData.provider !== provider || stateData.expiresAt < Date.now()) {
+        return res.status(400).send('Invalid or expired state');
+    }
+    oauthStates.delete(state);
+    // 尝试判断前端地址，如果是开发环境通常是 5173，生产环境可能是同源
+    const protocol = req.protocol || 'http';
+    const host = req.get('host') || 'localhost:3001';
+    // 简单策略：重定向回同源的 /settings（前端路由会处理）
+    const frontendBaseUrl = host.includes('3001') && process.env.NODE_ENV !== 'production'
+        ? 'http://localhost:5173'
+        : `${protocol}://${host}`;
+    try {
+        let tokenData;
+        if (provider === 'lark') {
+            const firstFeishuBot = config.channels?.feishu?.[0];
+            const appId = firstFeishuBot?.appId;
+            const appSecret = firstFeishuBot?.appSecret;
+            if (!appId || !appSecret) {
+                throw new Error('Feishu credentials not configured');
+            }
+            // 1. 获取 app_access_token
+            const appTokenRes = await axios.post('https://open.feishu.cn/open-apis/auth/v3/app_access_token/internal', {
+                app_id: appId,
+                app_secret: appSecret
+            });
+            const appAccessToken = appTokenRes.data.app_access_token;
+            // 2. 用 code 换取 user_access_token
+            const userTokenRes = await axios.post('https://open.feishu.cn/open-apis/authen/v1/oidc/access_token', {
+                grant_type: 'authorization_code',
+                code: code
+            }, {
+                headers: { 'Authorization': `Bearer ${appAccessToken}` }
+            });
+            tokenData = userTokenRes.data.data;
+            oauthTokens.set('lark', tokenData); // 实际应持久化
+        }
+        else if (provider === 'wps') {
+            const appId = process.env.WPS_APP_ID || '';
+            const appSecret = process.env.WPS_APP_SECRET || '';
+            if (!appId || !appSecret) {
+                throw new Error('WPS credentials not configured in environment variables');
+            }
+            // WPS 用 code 换 token
+            const tokenRes = await axios.post('https://openapi.wps.cn/oauthapi/v2/token', {
+                app_id: appId,
+                app_secret: appSecret,
+                grant_type: 'authorization_code',
+                code: code
+            });
+            tokenData = tokenRes.data;
+            oauthTokens.set('wps', tokenData); // 实际应持久化
+        }
+        console.log(`[OAuth] Successfully authenticated with ${provider}`);
+        // 更新内存中的插件状态为已启用
+        const pluginId = provider === 'wps' ? 'wps_office' : 'lark_docs';
+        if (thirdPartySkillsMeta[pluginId]) {
+            thirdPartySkillsMeta[pluginId].enabled = true;
+            // 实际项目中，这里应该实例化对应的 Skill 类并调用 skillRegistry.register()
+            // 例如: skillRegistry.register(new LarkDocSkill(tokenData.access_token));
+        }
+        // 授权成功，重定向回前端并带上成功标志
+        res.redirect(`${frontendBaseUrl}/?auth_success=true&provider=${provider}`);
+    }
+    catch (error) {
+        console.error(`[OAuth] Failed to exchange token for ${provider}:`, error.response?.data || error.message);
+        res.redirect(`${frontendBaseUrl}/?auth_success=false&error=token_exchange_failed`);
+    }
+});
+app.get('/api/projects', async (req, res) => {
+    try {
+        const list = memory.structured.listProjects();
+        res.json(list);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.post('/api/projects', async (req, res) => {
+    try {
+        const { id, name, description, departments, members, directory } = req.body;
+        if (!id || !name) {
+            res.status(400).json({ error: 'id and name are required' });
+            return;
+        }
+        memory.structured.createProject(id, name, description, departments, members, directory);
+        const item = memory.structured.getProject(id);
+        res.json(item);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.patch('/api/projects/:id', async (req, res) => {
+    try {
+        const { name, description, departments, members, directory } = req.body;
+        memory.structured.updateProject(req.params.id, { name, description, departments, members, directory });
+        const item = memory.structured.getProject(req.params.id);
+        res.json(item);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.delete('/api/projects/:id', async (req, res) => {
+    try {
+        memory.structured.deleteProject(req.params.id);
+        res.json({ status: 'success' });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// Notebooks CRUD
+app.get('/api/notebooks', async (req, res) => {
+    try {
+        const list = memory.structured.listNotebooks();
+        res.json(list);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.post('/api/notebooks', async (req, res) => {
+    try {
+        const { id, name, description, keywords } = req.body;
+        if (!id || !name) {
+            res.status(400).json({ error: 'id and name are required' });
+            return;
+        }
+        memory.structured.createNotebook(id, name, description, keywords);
+        const item = memory.structured.getNotebook(id);
+        res.json(item);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.patch('/api/notebooks/:id', async (req, res) => {
+    try {
+        const { name, description, keywords } = req.body;
+        memory.structured.updateNotebook(req.params.id, { name, description, keywords });
+        const item = memory.structured.getNotebook(req.params.id);
+        res.json(item);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.delete('/api/notebooks/:id', async (req, res) => {
+    try {
+        memory.structured.deleteNotebook(req.params.id);
+        res.json({ status: 'success' });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// Notes CRUD
+app.get('/api/notes', async (req, res) => {
+    try {
+        const notebookId = req.query.notebookId;
+        const list = memory.structured.listNotes(notebookId);
+        res.json(list);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.post('/api/notes', async (req, res) => {
+    try {
+        const { id, notebookId, title, content, isTodo, done } = req.body;
+        if (!id || !notebookId || !title) {
+            res.status(400).json({ error: 'id, notebookId and title are required' });
+            return;
+        }
+        memory.structured.createNote(id, notebookId, title, content, isTodo, done);
+        const item = memory.structured.getNote(id);
+        res.json(item);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.patch('/api/notes/:id', async (req, res) => {
+    try {
+        const { title, content, isTodo, done } = req.body;
+        memory.structured.updateNote(req.params.id, { title, content, isTodo, done });
+        const item = memory.structured.getNote(req.params.id);
+        res.json(item);
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+app.delete('/api/notes/:id', async (req, res) => {
+    try {
+        memory.structured.deleteNote(req.params.id);
+        res.json({ status: 'success' });
+    }
+    catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+// 初始化 Agents
+agentManager.registerAgent(createOfficeAgent());
+// 初始化插件管理器
+const pluginManager = new PluginManager(path.join(process.cwd(), 'plugins'));
+await pluginManager.loadPlugins();
+// 初始化通道
+const channels = createChannels({ app, io, config, pluginManager });
+for (const ch of channels) {
+    if (ch instanceof WebChannel) {
+        ch.setSyncHandler(async (sessionId, since) => {
+            const session = await memory.getSession(sessionId);
+            if (!session)
+                return { messages: [], runs: [] };
+            const runs = await memory.listRuns(sessionId);
+            const sinceTs = typeof since === 'number' ? since : 0;
+            const messages = (session.messages || []).filter((m) => (m.timestamp ?? 0) > sinceTs);
+            return { messages, runs };
+        });
+    }
+}
+// 启动通道并绑定事件
+channels.forEach(channel => {
+    channel.start();
+    // 监听通道消息 -> 发送到 EventBus
+    channel.onMessage((sessionId, message) => {
+        eventBus.emitEvent({
+            type: 'message',
+            payload: { content: message },
+            channel: channel.name,
+            sessionId: sessionId,
+            timestamp: Date.now()
+        });
+    });
+});
+// 核心逻辑：监听 EventBus 消息 -> Brain 处理 -> 发回 EventBus
+eventBus.onEvent('message', async (event) => {
+    const { sessionId, payload, channel: channelName } = event;
+    const content = payload.content;
+    try {
+        console.log(`[EventBus] Processing message for session: ${sessionId}`);
+        let session = await memory.getSession(sessionId);
+        if (!session) {
+            // 对于第三方 Channel (如 Feishu)，如果 Session 不存在，自动创建
+            if (channelName === 'feishu' || channelName === 'telegram' || channelName === 'dingtalk' || channelName === 'wechat') {
+                console.log(`[EventBus] Auto-creating session for ${channelName}: ${sessionId}`);
+                // 使用传入的 sessionId 作为 id，避免生成新的 uuid
+                // 注意：memory.createSession 默认生成 UUID，我们需要支持指定 ID
+                // 但 memory.createSession 目前不支持指定 ID，它调用 shortTerm.createSession
+                // 所以我们需要扩展 createSession 或者使用一种特殊方式
+                // 这里采用一种更简单的策略：如果是第三方渠道，我们允许 ShortTermMemory 懒加载/自动创建
+                // 或者在这里先创建一个标准 Session，然后映射？
+                // 不，sessionId 必须保持一致 (e.g. feishu:chat_id) 才能在后续消息中找到上下文
+                // 让我们修改 ShortTermMemory 的 createSession 逻辑，或者直接在这里 hack
+                // 但最好的方式是让 memory.createSession 支持自定义 ID
+                // 临时方案：如果 memory 支持 ensureSession
+                // 实际上，我们应该修改 MemoryManager 和 ShortTermMemory 支持 `createSession({ id: ... })`
+                // 由于现在无法直接修改底层接口，我们尝试调用 createSession 并忽略返回的 ID？不对。
+                // 正确的做法：
+                // 第三方 Channel 的 SessionID 通常是固定的 (如 `feishu:123`)。
+                // 我们需要 ShortTermMemory 支持 `getOrCreateSession(id)`
+                // 暂时先用 createSession 创建一个带 alias 的 session，
+                // 但这样 sessionId 会变，导致无法匹配。
+                // 关键点：EventBus 接收到的 sessionId 是 `feishu:xxx`。
+                // 我们必须确保数据库里有一个 ID 为 `feishu:xxx` 的 session。
+                // 现有的 `createSession` 会生成 UUID。
+                // 让我们修改 memory.createSession 及其底层实现来支持自定义 ID。
+                // 现在先报错，提示需要修改 ShortTermMemory。
+                // 但为了不中断流程，我们假设 ShortTermMemory.createSession 能够接受 id 参数
+                // 实际上，查看 memory.ts，createSession 调用 shortTerm.createSession
+                // 查看 short-term.ts (需要 read)，createSession 确实生成了 uuid。
+                // 为了快速修复，我们在 index.ts 里做不到，必须去修改 ShortTermMemory。
+                // 假设我们已经修改了（下一步操作），这里我们调用一个新的方法
+                session = await memory.createSession({ id: sessionId, alias: `${channelName} Session` });
+            }
+            else {
+                console.error(`[EventBus] Session not found: ${sessionId}`);
+                throw new Error('Session not found. Please create or select a session first.');
+            }
+        }
+        await memory.addMessage(sessionId, { role: 'user', content, timestamp: Date.now() });
+        const run = await memory.createRun(sessionId, content);
+        eventBus.emitEvent({
+            type: 'run_ack',
+            payload: { runId: run.id },
+            channel: channelName,
+            sessionId,
+            timestamp: Date.now()
+        });
+        eventBus.emitEvent({
+            type: 'run_status',
+            payload: { runId: run.id, status: 'queued' },
+            channel: channelName,
+            sessionId,
+            timestamp: Date.now()
+        });
+        taskQueue.enqueue({ run, channel: channelName });
+    }
+    catch (error) {
+        console.error('Error processing message:', error);
+        try {
+            await memory.addMessage(sessionId, { role: 'assistant', content: `Error: ${error.message}`, timestamp: Date.now() });
+        }
+        catch {
+            // ignore
+        }
+        eventBus.emitEvent({
+            type: 'error',
+            payload: { error: error.message },
+            channel: channelName,
+            sessionId: sessionId,
+            timestamp: Date.now()
+        });
+    }
+});
+// 监听 EventBus 响应 -> 发送给通道
+eventBus.onEvent('response', (event) => {
+    const { sessionId, payload, channel: channelName } = event;
+    const channel = channels.find(c => c.name === channelName);
+    if (channel) {
+        channel.send(sessionId, payload.content);
+    }
+});
+eventBus.onEvent('run_ack', (event) => {
+    const { sessionId, payload, channel: channelName } = event;
+    const channel = channels.find(c => c.name === channelName);
+    if (channel?.sendEvent) {
+        channel.sendEvent(sessionId, 'run_ack', payload);
+    }
+});
+eventBus.onEvent('run_status', (event) => {
+    const { sessionId, payload, channel: channelName } = event;
+    const channel = channels.find(c => c.name === channelName);
+    if (channel?.sendEvent) {
+        channel.sendEvent(sessionId, 'run_status', payload);
+    }
+});
+eventBus.onEvent('error', (event) => {
+    const { sessionId, payload, channel: channelName } = event;
+    const channel = channels.find(c => c.name === channelName);
+    if (channel) {
+        channel.send(sessionId, `Error: ${payload.error}`);
+    }
+});
+// 启动记忆维护任务（自动清理过期记忆）
+initScheduler();
+// 启动服务器
+const PORT = config.server.port;
+httpServer.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
+    console.log(`Socket.IO server running`);
+});
+httpServer.on('error', (err) => {
+    console.error('[Server] Startup error:', err);
+    if (err.code === 'EADDRINUSE') {
+        console.error(`Port ${PORT} is already in use.`);
+        process.exit(1);
+    }
+});
+// Graceful shutdown
+const shutdown = () => {
+    console.log('Shutting down server...');
+    httpServer.close(() => {
+        console.log('Server closed');
+        process.exit(0);
+    });
+};
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);