xiaozuoassistant 0.1.41

package/dist/server/core/memories/vector.js

@@ -0,0 +1,138 @@
+import * as lancedb from '@lancedb/lancedb';
+import path from 'path';
+import fs from 'fs-extra';
+import { config } from '../../config/loader.js';
+import { createOpenAIClient } from '../../llm/openai.js';
+const VECTOR_DB_DIR = path.resolve(process.cwd(), 'data/lancedb');
+export class VectorMemory {
+    constructor() {
+        this.openai = null;
+        this.isInitialized = false;
+        fs.ensureDirSync(VECTOR_DB_DIR);
+        this.updateClient();
+        this.initDB();
+    }
+    updateClient() {
+        this.openai = config.llm.apiKey ? createOpenAIClient(config.llm) : null;
+    }
+    static getInstance() {
+        if (!VectorMemory.instance) {
+            VectorMemory.instance = new VectorMemory();
+        }
+        return VectorMemory.instance;
+    }
+    async initDB() {
+        try {
+            this.db = await lancedb.connect(VECTOR_DB_DIR);
+            // Ensure table exists
+            const tableNames = await this.db.tableNames();
+            if (!tableNames.includes('memories')) {
+                // Create table with dummy data to define schema, then delete it
+                // LanceDB schema inference is based on data
+                const dummyData = [{
+                        id: 'init',
+                        text: 'init',
+                        vector: Array(1536).fill(0), // OpenAI embedding dimension
+                        metadata: { type: 'recent', timestamp: Date.now(), sessionId: 'init', tags: '' }
+                    }];
+                this.table = await this.db.createTable('memories', dummyData);
+                // await this.table.delete('id = "init"'); // Older lancedb syntax might differ
+            }
+            else {
+                this.table = await this.db.openTable('memories');
+            }
+            this.isInitialized = true;
+        }
+        catch (error) {
+            console.error('Failed to init LanceDB:', error);
+        }
+    }
+    async getEmbedding(text) {
+        if (!this.openai) {
+            console.warn('OpenAI client not initialized (missing API Key), skipping embedding.');
+            return Array(1536).fill(0);
+        }
+        try {
+            // Use OpenAI compatible embedding endpoint
+            // Note: Some compatible providers might use different models/dimensions.
+            // Default to text-embedding-ada-002 or similar standard.
+            // For DashScope/Qwen, we might need 'text-embedding-v1' or similar if 'text-embedding-v3-small' fails.
+            // We'll try to use a more standard one or catch the error.
+            const response = await this.openai.embeddings.create({
+                model: 'text-embedding-v1', // Common alias in compatible APIs, or use config if available
+                input: text,
+            });
+            return response.data[0].embedding;
+        }
+        catch (error) {
+            console.error('Embedding failed:', error);
+            // Fallback: return zero vector or throw? 
+            // For MVP robustness, return zeros if embedding fails (search won't work but app won't crash)
+            return Array(1536).fill(0);
+        }
+    }
+    async addMemory(text, type, metadata = {}) {
+        if (!this.isInitialized)
+            await this.initDB();
+        if (!this.table)
+            return; // DB failed to init
+        const vector = await this.getEmbedding(text);
+        const memory = {
+            id: Math.random().toString(36).substring(7),
+            text,
+            vector,
+            metadata: {
+                type,
+                timestamp: Date.now(),
+                ...metadata
+            }
+        };
+        try {
+            await this.table.add([memory]);
+        }
+        catch (e) {
+            console.error('Failed to add memory to vector db:', e);
+        }
+    }
+    async search(query, type, limit = 5) {
+        if (!this.isInitialized)
+            await this.initDB();
+        if (!this.table)
+            return [];
+        const vector = await this.getEmbedding(query);
+        // Check if table supports search
+        if (this.table.search) {
+            let search = this.table.search(vector).limit(limit);
+            if (type) {
+                try {
+                    // Using simpler filter to avoid Dictionary type issues
+                    // search = search.where(`metadata.type = '${type}'`);
+                    // Skip filtering for now to avoid lancedb issues
+                }
+                catch (e) {
+                    console.warn('Filter not supported in this LanceDB version/mode, filtering manually');
+                }
+            }
+            try {
+                const results = await search.execute();
+                return results.map((r) => ({
+                    id: r.id,
+                    text: r.text,
+                    vector: r.vector,
+                    metadata: r.metadata
+                }));
+            }
+            catch (e) {
+                console.error('Vector search failed:', e);
+                return [];
+            }
+        }
+        return [];
+    }
+    async getMemoriesOlderThan(maxAgeDays) {
+        return []; // Disable for now to avoid build errors with older lancedb types
+    }
+    async pruneOldMemories(maxAgeDays) {
+        return 0; // Disable for now
+    }
+}

package/dist/server/core/memory.js

@@ -0,0 +1,2 @@
+import { memoryManager } from './memories/manager.js';
+export const memory = memoryManager;

package/dist/server/core/plugin-manager.js

@@ -0,0 +1,112 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { skillRegistry } from '../skills/registry.js';
+export class PluginManager {
+    constructor(pluginDir) {
+        this.plugins = new Map();
+        this.channels = [];
+        this.pluginDir = pluginDir;
+    }
+    getChannels() {
+        return this.channels;
+    }
+    createContext(pluginName) {
+        return {
+            registerSkill: (skill) => {
+                console.log(`[PluginManager] Plugin '${pluginName}' registered skill: ${skill.name}`);
+                // Inject plugin name into skill for tracking if needed
+                skill.pluginName = pluginName;
+                skillRegistry.register(skill);
+            },
+            registerChannel: (channel) => {
+                console.log(`[PluginManager] Plugin '${pluginName}' registered channel: ${channel.name}`);
+                this.channels.push(channel);
+                // Note: Channels registered after app start might need manual starting if the app is already running.
+                // For simplicity in this MVP, we assume plugins are loaded at startup.
+            },
+            logger: {
+                info: (msg) => console.log(`[Plugin:${pluginName}] ${msg}`),
+                warn: (msg) => console.warn(`[Plugin:${pluginName}] ${msg}`),
+                error: (msg) => console.error(`[Plugin:${pluginName}] ${msg}`),
+            }
+        };
+    }
+    async loadPlugins() {
+        try {
+            // Ensure plugin directory exists
+            try {
+                await fs.access(this.pluginDir);
+            }
+            catch {
+                console.log(`[PluginManager] Plugin directory ${this.pluginDir} does not exist. Creating...`);
+                await fs.mkdir(this.pluginDir, { recursive: true });
+                return;
+            }
+            const entries = await fs.readdir(this.pluginDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    await this.loadPluginFromDir(path.join(this.pluginDir, entry.name));
+                }
+            }
+        }
+        catch (error) {
+            console.error('[PluginManager] Error loading plugins:', error);
+        }
+    }
+    async loadPluginFromDir(dirPath) {
+        try {
+            // Check for package.json or index.js/ts
+            const pkgPath = path.join(dirPath, 'package.json');
+            const indexPath = path.join(dirPath, 'index.js'); // Assuming compiled JS for now, or ts-node handling
+            let entryPoint = indexPath;
+            // Try to read package.json main field
+            try {
+                const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+                const pkg = JSON.parse(pkgContent);
+                if (pkg.main) {
+                    entryPoint = path.join(dirPath, pkg.main);
+                }
+            }
+            catch (e) {
+                // No package.json, assume index.js
+            }
+            // Dynamic import
+            // Note: In a real-world scenario, we might need to handle CJS/ESM compatibility carefully.
+            // Here we assume the plugin exports a default object implementing the Plugin interface.
+            // Ensure we are importing a file that exists
+            try {
+                await fs.access(entryPoint);
+            }
+            catch {
+                // Try .ts if .js doesn't exist (for dev mode with tsx/ts-node)
+                if (entryPoint.endsWith('.js')) {
+                    const tsEntryPoint = entryPoint.replace(/\.js$/, '.ts');
+                    try {
+                        await fs.access(tsEntryPoint);
+                        entryPoint = tsEntryPoint;
+                    }
+                    catch {
+                        // console.warn(`[PluginManager] Could not find entry point for plugin at ${dirPath}`);
+                        return;
+                    }
+                }
+                else {
+                    return;
+                }
+            }
+            const pluginModule = await import(entryPoint);
+            const plugin = pluginModule.default || pluginModule;
+            if (!plugin.metadata || !plugin.onLoad) {
+                console.warn(`[PluginManager] Invalid plugin structure in ${dirPath}`);
+                return;
+            }
+            console.log(`[PluginManager] Loading plugin: ${plugin.metadata.name} (${plugin.metadata.version})`);
+            const context = this.createContext(plugin.metadata.name);
+            await plugin.onLoad(context);
+            this.plugins.set(plugin.metadata.name, plugin);
+        }
+        catch (error) {
+            console.error(`[PluginManager] Failed to load plugin from ${dirPath}:`, error);
+        }
+    }
+}

package/dist/server/core/plugin.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/scheduler.js

@@ -0,0 +1,24 @@
+import cron from 'node-cron';
+import { memoryManager } from './memories/manager.js';
+import { config } from '../config/loader.js';
+let cronTask = null;
+export const initScheduler = () => {
+    // Stop existing task if any
+    if (cronTask) {
+        cronTask.stop();
+        cronTask = null;
+    }
+    // Default: Every day at midnight
+    const cronSchedule = config.scheduler?.memoryMaintenanceCron || '0 0 * * *';
+    console.log(`[Scheduler] Initializing memory maintenance job with schedule: "${cronSchedule}"`);
+    // Only run immediately on initial startup, not every restart (optional)
+    // Or we can assume restart means config changed, so maybe we don't need to run immediately?
+    // Let's keep it simple: only schedule the cron job. Immediate run can be manual via API.
+    cronTask = cron.schedule(cronSchedule, () => {
+        memoryManager.runMaintenance();
+    });
+};
+export const runMaintenanceNow = () => {
+    console.log('[Scheduler] Manually triggering maintenance...');
+    memoryManager.runMaintenance();
+};

package/dist/server/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/index.js

@@ -0,0 +1,318 @@
+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 { memory } from './core/memory.js';
+import { skillRegistry } from './skills/registry.js';
+import { SystemTimeSkill } from './skills/system-time.js';
+import { SearchSkill } from './skills/search.js';
+import { ListDirectorySkill, ReadFileSkill, WriteFileSkill, DeleteFileSkill } from './skills/file-system.js';
+import { PluginManager } from './core/plugin-manager.js';
+import { initScheduler, runMaintenanceNow } from './core/scheduler.js';
+import { agentManager } from './core/agents/manager.js';
+import { createOfficeAgent } from './agents/office.js';
+import { DelegateSkill } from './skills/delegate.js';
+import { createChannels } from './channels/create-channels.js';
+import { createHttpStack } from './server/create-http.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) => {
+    const sessions = await memory.listSessions();
+    res.json(sessions);
+});
+// 获取会话详情
+app.get('/api/sessions/:id', async (req, res) => {
+    const session = await memory.getSession(req.params.id);
+    if (session) {
+        res.json(session);
+    }
+    else {
+        res.status(404).json({ error: 'Session not found' });
+    }
+});
+// 创建新会话
+app.post('/api/sessions', async (req, res) => {
+    const session = await memory.createSession();
+    res.json(session);
+});
+// 删除会话
+app.delete('/api/sessions/:id', async (req, res) => {
+    await memory.deleteSession(req.params.id);
+    res.json({ status: 'success', message: 'Session deleted' });
+});
+// 文件选择接口 (使用系统默认文件对话框可能需要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({
+        apiKey: config.llm.apiKey,
+        baseURL: config.llm.baseURL,
+        model: config.llm.model,
+        temperature: config.llm.temperature,
+        systemPrompt: config.systemPrompt,
+        memoryMaintenanceCron: config.scheduler?.memoryMaintenanceCron,
+        workspace: config.workspace
+    });
+});
+// 更新配置并写入 config.json
+app.post('/api/config', async (req, res) => {
+    try {
+        const { apiKey, baseURL, model, temperature, systemPrompt, memoryMaintenanceCron, workspace } = req.body;
+        // 更新配置对象
+        const newConfig = { ...config };
+        if (apiKey !== undefined)
+            newConfig.llm.apiKey = apiKey;
+        if (baseURL !== undefined)
+            newConfig.llm.baseURL = baseURL;
+        if (model !== undefined)
+            newConfig.llm.model = model;
+        if (temperature !== undefined)
+            newConfig.llm.temperature = parseFloat(temperature);
+        if (systemPrompt !== undefined)
+            newConfig.systemPrompt = systemPrompt;
+        if (workspace !== undefined)
+            newConfig.workspace = workspace;
+        // Handle System Prompt update logic
+        // We only update systemPrompt automatically if workspace changed OR it's a new config
+        // But if user manually edited systemPrompt in the same request, we should respect that?
+        // The current frontend sends all fields.
+        // If workspace changed, we append/update it.
+        // Simplification: Always ensure the workspace is in the system prompt if configured.
+        if (newConfig.workspace) {
+            const workspaceLine = `Current Workspace: ${newConfig.workspace}`;
+            // If system prompt doesn't have it, append it.
+            if (!newConfig.systemPrompt) {
+                newConfig.systemPrompt = workspaceLine;
+            }
+            else if (!newConfig.systemPrompt.includes('Current Workspace:')) {
+                newConfig.systemPrompt += `\n${workspaceLine}`;
+            }
+            else {
+                // It has it, let's update it to match new workspace
+                // We use a regex to replace the line
+                newConfig.systemPrompt = newConfig.systemPrompt.replace(/Current Workspace: .*/, workspaceLine);
+            }
+        }
+        let restartScheduler = false;
+        if (memoryMaintenanceCron !== undefined) {
+            if (!newConfig.scheduler)
+                newConfig.scheduler = {};
+            if (newConfig.scheduler.memoryMaintenanceCron !== memoryMaintenanceCron) {
+                newConfig.scheduler.memoryMaintenanceCron = memoryMaintenanceCron;
+                restartScheduler = true;
+            }
+        }
+        // 保存到文件
+        saveConfig(newConfig);
+        // 如果 LLM 配置变了，更新 Brain
+        brain.updateClient();
+        // 如果定时任务配置变了，重启 Scheduler
+        if (restartScheduler) {
+            initScheduler();
+        }
+        res.json({ status: 'success', message: 'Config updated and saved to config.json' });
+    }
+    catch (error) {
+        res.status(500).json({ status: 'error', message: error.message });
+    }
+});
+// 手动触发记忆维护
+app.post('/api/scheduler/run', async (req, res) => {
+    try {
+        runMaintenanceNow();
+        res.json({ status: 'success', message: 'Memory maintenance triggered.' });
+    }
+    catch (e) {
+        res.status(500).json({ status: 'error', message: e.message });
+    }
+});
+import { ReadWordSkill, CreateWordSkill } from './skills/office-word.js';
+import { ReadExcelSkill, CreateExcelSkill } from './skills/office-excel.js';
+import { CreatePptxSkill } from './skills/office-ppt.js';
+import { CreateAgentSkill } from './skills/create-agent.js';
+import { ListAgentsSkill } from './skills/list-agents.js';
+// 初始化 Agents
+agentManager.registerAgent(createOfficeAgent());
+// 注册技能
+skillRegistry.register(new CreateAgentSkill()); // 允许动态创建 Agent
+skillRegistry.register(new ListAgentsSkill()); // 允许列出所有 Agent
+skillRegistry.register(new DelegateSkill()); // 允许主 Brain 委派任务
+skillRegistry.register(new SystemTimeSkill());
+skillRegistry.register(new SearchSkill());
+skillRegistry.register(new ListDirectorySkill());
+skillRegistry.register(new ReadFileSkill());
+skillRegistry.register(new WriteFileSkill());
+skillRegistry.register(new DeleteFileSkill());
+skillRegistry.register(new ReadWordSkill());
+skillRegistry.register(new CreateWordSkill());
+skillRegistry.register(new ReadExcelSkill());
+skillRegistry.register(new CreateExcelSkill());
+skillRegistry.register(new CreatePptxSkill());
+// 初始化插件管理器
+const pluginManager = new PluginManager(path.resolve(process.cwd(), 'plugins'));
+await pluginManager.loadPlugins();
+// 初始化通道
+const channels = createChannels({ app, io, config, pluginManager });
+// 启动通道并绑定事件
+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 {
+        // 1. 获取会话上下文
+        let session = await memory.getSession(sessionId);
+        if (!session) {
+            session = await memory.createSession();
+            // 如果是新创建的会话，可能需要通知前端更新 ID（略复杂，暂且假设前端已获取 ID）
+        }
+        // 2. 记录用户消息
+        await memory.addMessage(sessionId, { role: 'user', content });
+        // 3. Brain 处理
+        // Use MemoryManager to retrieve full context (Short-term + Recent + Structured)
+        const context = await memory.getRelevantContext(content, sessionId);
+        // We pass the raw messages to processMessage for now, but Brain should ideally use the enhanced context.
+        // Let's modify Brain.processMessage to accept an optional context string or just prepend it.
+        // For this MVP, we will prepend the context to the system prompt or as a new system message.
+        // Or simpler: We just pass session.messages as before, but Brain needs to know about the context.
+        // Let's change how we call brain.processMessage.
+        // Construct a temporary history with enhanced context for the LLM
+        const enhancedSystemPrompt = `You are xiaozuoAssistant, a helpful AI assistant.
+Here is some relevant context from your memory:
+${context}`;
+        // We need to inject this into the Brain. 
+        // Since Brain.processMessage takes history, let's just pass the history but we need to tell Brain to use this system prompt.
+        // We can modify Brain to accept a system prompt override.
+        // Or we can just create a new method in Brain or pass it as an argument.
+        // Let's update Brain.processMessage signature in next step. For now, let's just pass the history.
+        const responseContent = await brain.processMessage(session.messages, content, enhancedSystemPrompt);
+        // 4. 记录 AI 响应
+        await memory.addMessage(sessionId, { role: 'assistant', content: responseContent });
+        // 5. 发送响应事件
+        eventBus.emitEvent({
+            type: 'response',
+            payload: { content: responseContent },
+            channel: channelName,
+            sessionId: sessionId,
+            timestamp: Date.now()
+        });
+    }
+    catch (error) {
+        console.error('Error processing message:', error);
+        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('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`);
+});

package/dist/server/llm/openai.js

@@ -0,0 +1,23 @@
+import OpenAI from 'openai';
+export function resolveBaseURL(config) {
+    switch (config.provider) {
+        case 'deepseek':
+            return 'https://api.deepseek.com';
+        case 'minimax':
+            return 'https://api.minimax.chat/v1';
+        case 'doubao':
+            return 'https://ark.cn-beijing.volces.com/api/v3';
+        case 'qwen':
+            return 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1';
+        case 'custom':
+        case 'openai':
+        default:
+            return config.baseURL;
+    }
+}
+export function createOpenAIClient(config) {
+    return new OpenAI({
+        apiKey: config.apiKey || '',
+        baseURL: resolveBaseURL(config)
+    });
+}

package/dist/server/routes/auth.js

@@ -0,0 +1,28 @@
+/**
+ * This is a user authentication API route demo.
+ * Handle user registration, login, token management, etc.
+ */
+import { Router } from 'express';
+const router = Router();
+/**
+ * User Login
+ * POST /api/auth/register
+ */
+router.post('/register', async (req, res) => {
+    // TODO: Implement register logic
+});
+/**
+ * User Login
+ * POST /api/auth/login
+ */
+router.post('/login', async (req, res) => {
+    // TODO: Implement login logic
+});
+/**
+ * User Logout
+ * POST /api/auth/logout
+ */
+router.post('/logout', async (req, res) => {
+    // TODO: Implement logout logic
+});
+export default router;

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

@@ -0,0 +1,17 @@
+import express from 'express';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import cors from 'cors';
+export function createHttpStack() {
+    const app = express();
+    const httpServer = createServer(app);
+    const io = new Server(httpServer, {
+        cors: {
+            origin: '*',
+            methods: ['GET', 'POST']
+        }
+    });
+    app.use(cors());
+    app.use(express.json());
+    return { app, httpServer, io };
+}