team-anya 0.2.0

package/apps/server/dist/loid/session-manager.js

@@ -0,0 +1,472 @@
+import { join } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import { ensureLoidWorkspace } from '@team-anya/core';
+import { getTasksByStatus, getChatContext, getCCSessionsByChat, updateCCSessionEnded } from '@team-anya/db';
+import { TaskStatus } from '@team-anya/core';
+import { LoidSession, } from './session.js';
+import { formatMessageContextPrompt, formatFollowUpPrompt, formatDeliveryContextPrompt, formatRecoveryPrompt, } from './context-builder.js';
+// ── LoidSessionManager ──
+export class LoidSessionManager {
+    sessions = new Map();
+    config;
+    deps;
+    logger;
+    /** 崩溃恢复中的话术池（像同事重启电脑一样自然） */
+    static CRASH_RECOVERY_REPLIES = [
+        '抱歉，刚才脑子卡了一下，我重新捋一下',
+        '不好意思，刚才断片了，我重新接上',
+        '刚才出了点状况，我重新来过',
+        '抱歉打断了，我重新整理一下思路',
+        '不好意思，刚才掉线了，马上接上',
+    ];
+    lastCrashRecoveryIndex = -1;
+    /** 限流请假话术池（像同事请假一样自然） */
+    static RATE_LIMIT_REPLIES = [
+        '🙋 抱歉，我今天处理太多事情了，需要歇一会儿。预计 {time} 恢复工作，这段时间新消息会排队，回来后优先处理。',
+        '🙋 不好意思，我体力不支了需要休息一下。预计 {time} 回来继续干活，不用担心，消息我都记着。',
+        '🙋 不好意思，我需要请个短假，大概 {time} 回来。这段时间的消息我会攒着，一回来就处理。',
+    ];
+    lastRateLimitIndex = -1;
+    /** 崩溃恢复失败 / 启动失败的话术池 */
+    static STARTUP_FAILURE_REPLIES = [
+        '抱歉，我这边遇到了点问题暂时处理不了，稍后我再试试，或者你可以再发一次',
+        '不好意思，出了点技术问题我暂时响应不了，你可以稍后再@我试试',
+        '抱歉，我这边卡住了，短时间内可能没法响应，你可以过一会儿再找我',
+    ];
+    lastStartupFailureIndex = -1;
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+        // 监听 Loid 实例限流事件
+        this.config.broker.on('instance.rate_limited', (instanceId, role, result) => {
+            if (role !== 'loid')
+                return;
+            const chatId = this.findChatIdByInstanceId(instanceId);
+            if (chatId && result.rateLimitInfo) {
+                this.sendRateLimitNotification(chatId, 'Loid', result.rateLimitInfo);
+            }
+        });
+    }
+    /** 从话术池随机取一句，避免连续重复 */
+    pickRandom(pool, lastIndex) {
+        let idx;
+        do {
+            idx = Math.floor(Math.random() * pool.length);
+        } while (idx === lastIndex && pool.length > 1);
+        return { text: pool[idx], index: idx };
+    }
+    pickCrashRecoveryReply() {
+        const { text, index } = this.pickRandom(LoidSessionManager.CRASH_RECOVERY_REPLIES, this.lastCrashRecoveryIndex);
+        this.lastCrashRecoveryIndex = index;
+        return text;
+    }
+    pickStartupFailureReply() {
+        const { text, index } = this.pickRandom(LoidSessionManager.STARTUP_FAILURE_REPLIES, this.lastStartupFailureIndex);
+        this.lastStartupFailureIndex = index;
+        return text;
+    }
+    // ── 公开方法 ──
+    /**
+     * 处理新消息：有活跃 session 就 enqueue，没有就创建
+     */
+    async handleMessage(chatId, ctx) {
+        const key = chatId;
+        const existing = this.sessions.get(key);
+        if (existing) {
+            const state = existing.getState();
+            if (state !== 'disposed') {
+                const prompt = formatFollowUpPrompt(ctx);
+                existing.enqueue({ type: 'message', prompt, enqueuedAt: new Date() });
+                return;
+            }
+            // session 已销毁，删除并新建
+            this.sessions.delete(key);
+        }
+        // 尝试从 DB 恢复之前的 session（程序重启场景）
+        const resumeSessionId = this.findResumableSession(key);
+        try {
+            if (resumeSessionId) {
+                try {
+                    const session = await this.createSession(key, resumeSessionId);
+                    this.logger.info(`[SessionManager] 从 DB 恢复 session (resume ${resumeSessionId}): ${key}`);
+                    const prompt = formatFollowUpPrompt(ctx);
+                    session.enqueue({ type: 'message', prompt, enqueuedAt: new Date() });
+                    return;
+                }
+                catch (resumeErr) {
+                    this.logger.error(`[SessionManager] resume 失败，fallback 到全新 session: ${resumeErr}`);
+                }
+            }
+            // 全新 session
+            const session = await this.createSession(key);
+            const contextPrompt = formatMessageContextPrompt(ctx);
+            session.enqueue({ type: 'message', prompt: contextPrompt, enqueuedAt: new Date() });
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.logger.error(`[SessionManager] 创建 session 失败 (${key}):\n${errMsg}`);
+            this.sendChatNotification(key, this.pickStartupFailureReply());
+        }
+    }
+    /**
+     * 处理 Yor 交付验收：查找来源 session，活着就复用，否则新建
+     */
+    async handleDelivery(ctx) {
+        const sourceChatId = ctx.sourceChatId;
+        // 尝试复用来源 session
+        if (sourceChatId && this.sessions.has(sourceChatId)) {
+            const session = this.sessions.get(sourceChatId);
+            const state = session.getState();
+            if (state !== 'disposed') {
+                const prompt = formatDeliveryContextPrompt(ctx);
+                session.enqueue({ type: 'delivery', prompt, enqueuedAt: new Date() });
+                return;
+            }
+            this.sessions.delete(sourceChatId);
+        }
+        // 来源 session 已回收，新建独立 session
+        const key = `delivery:${ctx.taskId}`;
+        try {
+            const session = await this.createSession(key);
+            const protocol = this.config.protocols['review'] ?? '';
+            const prompt = [
+                protocol ? protocol + '\n\n---\n\n' : '',
+                formatDeliveryContextPrompt(ctx),
+            ].join('');
+            session.enqueue({ type: 'delivery', prompt, enqueuedAt: new Date() });
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.logger.error(`[SessionManager] 创建 delivery session 失败 (${key}):\n${errMsg}`);
+            // delivery 场景通知来源群
+            if (ctx.sourceChatId) {
+                this.sendChatNotification(ctx.sourceChatId, this.pickStartupFailureReply());
+            }
+        }
+    }
+    /**
+     * 获取当前活跃 session 数量
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * 获取指定 session 的状态（用于诊断）
+     */
+    getSessionState(key) {
+        return this.sessions.get(key)?.getState() ?? null;
+    }
+    /**
+     * 重启指定 chatId 的 Loid session（/restart 命令）
+     * dispose 当前 session + 标记 DB 中所有未结束的 session 为已结束，
+     * 确保下次来消息时走全新 session 而非 resume
+     */
+    async restartChat(chatId) {
+        const key = chatId;
+        const session = this.sessions.get(key);
+        if (session) {
+            await session.dispose();
+            this.sessions.delete(key);
+        }
+        // 标记 DB 中所有未结束的 loid session 为已结束，防止下次 resume
+        try {
+            const dbSessions = getCCSessionsByChat(this.deps.db, chatId);
+            for (const s of dbSessions) {
+                if (s.role === 'loid' && !s.ended_at) {
+                    updateCCSessionEnded(this.deps.db, s.session_id);
+                }
+            }
+        }
+        catch (err) {
+            this.logger.error('[SessionManager] restart 清理 DB session 失败:', err);
+        }
+    }
+    /**
+     * 关闭所有 session，释放资源
+     */
+    async dispose() {
+        const disposePromises = [];
+        for (const [key, session] of this.sessions) {
+            this.logger.info(`[SessionManager] 正在关闭 session: ${key}`);
+            disposePromises.push(session.dispose());
+        }
+        await Promise.all(disposePromises);
+        this.sessions.clear();
+        this.logger.info('[SessionManager] 所有 session 已关闭');
+    }
+    // ── 私有方法 ──
+    /**
+     * 创建新 LoidSession，注册生命周期回调
+     * 如果 broker 槽位满，尝试 LRU 淘汰后重试
+     * @param resumeSessionId 传入则尝试 resume 到之前的 CC session
+     */
+    async createSession(key, resumeSessionId) {
+        this.logger.info(`[SessionManager] 创建新 session: ${key}`);
+        // per-chatId 工作区：sanitize key 作为目录名
+        const safeDirName = key.replace(/[/:]/g, '_');
+        const workDir = join(this.config.loidBaseDir, safeDirName);
+        // 确保工作区就绪（模板同步 + 共享目录 symlink）
+        await ensureLoidWorkspace(workDir, this.config.templateDir, this.config.officePath, this.logger);
+        // 写入 chat-context.md（基于 DB 中的 chat 绑定配置）
+        await this.writeChatContext(key, workDir);
+        const instanceId = `loid:${key}`;
+        const logFile = this.config.logDir
+            ? join(this.config.logDir, `loid-${safeDirName}-${Date.now()}.log`)
+            : undefined;
+        const sessionConfig = {
+            broker: this.config.broker,
+            instanceId,
+            backendConfig: { ...this.config.backendConfigTemplate, workingDir: workDir },
+            idleTimeoutMs: this.config.idleTimeoutMs,
+            maxTurns: this.config.maxTurnsPerSession,
+            logFile,
+            db: this.deps.db,
+            chatId: key,
+            logger: this.logger,
+        };
+        const session = new LoidSession(sessionConfig, {
+            onCrash: (orphanMessages, savedSessionId) => {
+                this.onSessionCrash(key, orphanMessages, savedSessionId);
+            },
+            onDisposed: () => {
+                this.logger.info(`[SessionManager] session 自然结束: ${key}`);
+                this.sessions.delete(key);
+            },
+        });
+        try {
+            await session.connect(resumeSessionId);
+        }
+        catch (err) {
+            // 槽位满时尝试 LRU 淘汰
+            if (err instanceof Error && err.message.includes('实例已满')) {
+                const evicted = await this.evictLRU();
+                if (evicted) {
+                    this.logger.info(`[SessionManager] LRU 淘汰 ${evicted}，重试创建 ${key}`);
+                    await session.connect(resumeSessionId);
+                }
+                else {
+                    throw err;
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+        this.sessions.set(key, session);
+        return session;
+    }
+    /**
+     * LRU 淘汰：找到最久没活动且处于 IDLE 的 session，dispose 它
+     * 返回被淘汰的 session key，无可淘汰时返回 null
+     */
+    async evictLRU() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+        for (const [key, session] of this.sessions) {
+            if (session.getState() === 'idle') {
+                const activityTime = session.getLastActivityAt().getTime();
+                if (activityTime < oldestTime) {
+                    oldestTime = activityTime;
+                    oldestKey = key;
+                }
+            }
+        }
+        if (oldestKey) {
+            const session = this.sessions.get(oldestKey);
+            await session.dispose();
+            this.sessions.delete(oldestKey);
+            this.logger.info(`[SessionManager] LRU 淘汰 session: ${oldestKey}`);
+            return oldestKey;
+        }
+        return null;
+    }
+    /**
+     * Session 崩溃恢复：优先 resume 旧 session（保留完整对话上下文），
+     * 失败则 fallback 到全新 session + recovery prompt
+     */
+    async onSessionCrash(key, orphanedMessages, cliSessionId) {
+        this.logger.error(`[SessionManager] session 崩溃: ${key} (${orphanedMessages.length} 条孤儿消息, sessionId=${cliSessionId ?? 'none'})`);
+        // 删除旧 session
+        this.sessions.delete(key);
+        // 通知用户：正在恢复
+        const chatId = this.extractChatId(key);
+        if (chatId) {
+            this.sendChatNotification(chatId, this.pickCrashRecoveryReply());
+        }
+        try {
+            // 优先尝试 resume（保留完整对话上下文）
+            if (cliSessionId) {
+                try {
+                    const resumedSession = await this.createSession(key, cliSessionId);
+                    this.logger.info(`[SessionManager] 崩溃恢复成功 (resume ${cliSessionId}): ${key}`);
+                    // 投递孤儿消息
+                    for (const msg of orphanedMessages) {
+                        resumedSession.enqueue(msg);
+                    }
+                    return;
+                }
+                catch (resumeErr) {
+                    this.logger.error(`[SessionManager] resume 失败，fallback 到全新 session: ${resumeErr}`);
+                }
+            }
+            // Fallback: 全新 session + recovery prompt
+            const activeTasks = this.getActiveTasks();
+            const recoveryPrompt = formatRecoveryPrompt(activeTasks);
+            const newSession = await this.createSession(key);
+            newSession.enqueue({ type: 'recovery', prompt: recoveryPrompt, enqueuedAt: new Date() });
+            for (const msg of orphanedMessages) {
+                newSession.enqueue(msg);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            this.logger.error(`[SessionManager] 崩溃恢复失败 (${key}):\n${errMsg}`);
+            if (chatId) {
+                this.sendChatNotification(chatId, this.pickStartupFailureReply());
+            }
+        }
+    }
+    /**
+     * 从 session key 提取 chatId（过滤掉 delivery: 等前缀的内部 key）
+     * 只有来自用户对话的 session 才需要通知
+     */
+    extractChatId(key) {
+        // delivery:ANYA-xxx 等内部 session 不直接通知用户
+        if (key.startsWith('delivery:'))
+            return null;
+        return key;
+    }
+    /**
+     * 通过 instanceId 反查 chatId（session key）
+     */
+    findChatIdByInstanceId(instanceId) {
+        for (const [key, session] of this.sessions) {
+            if (instanceId === `loid:${key}`)
+                return this.extractChatId(key);
+        }
+        return null;
+    }
+    /**
+     * 发送限流"请假"通知
+     */
+    sendRateLimitNotification(chatId, roleName, info) {
+        const resetTime = new Date(info.resetsAt * 1000);
+        const timeStr = resetTime.toLocaleTimeString('zh-CN', {
+            hour: '2-digit',
+            minute: '2-digit',
+            timeZone: 'Asia/Shanghai',
+        });
+        const { text, index } = this.pickRandom(LoidSessionManager.RATE_LIMIT_REPLIES, this.lastRateLimitIndex);
+        this.lastRateLimitIndex = index;
+        const message = text.replace('{time}', timeStr);
+        this.logger.info(`[SessionManager] 限流通知 (${chatId}): ${roleName} 请假至 ${timeStr}`);
+        this.sendChatNotification(chatId, message);
+    }
+    /**
+     * 向飞书群发送通知（fire-and-forget），同时清除"处理中"表情
+     */
+    sendChatNotification(chatId, text) {
+        if (!this.deps.feishuSender)
+            return;
+        // 清除 typing reaction（通知本身就是反馈）
+        this.deps.feishuSender.clearTypingReaction(chatId).catch(() => { });
+        this.deps.feishuSender.sendText({
+            receiveIdType: 'chat_id',
+            receiveId: chatId,
+            text,
+        }).catch(err => {
+            this.logger.error('[SessionManager] 崩溃通知发送失败:', err);
+        });
+    }
+    /**
+     * 写入 chat-context.md 到工作区（基于 DB 中的绑定配置）
+     * 无绑定时删除文件（如存在）
+     */
+    async writeChatContext(chatId, workDir) {
+        const contextFile = join(workDir, 'chat-context.md');
+        try {
+            const chatCtx = getChatContext(this.deps.db, chatId);
+            if (!chatCtx?.default_project_id && !chatCtx?.custom_context) {
+                // 无绑定，不写文件
+                return;
+            }
+            const lines = ['# 对话上下文设定', ''];
+            // 项目绑定
+            if (chatCtx.default_project_id && this.deps.projectRegistry) {
+                const project = this.deps.projectRegistry.findProject(chatCtx.default_project_id);
+                if (project) {
+                    lines.push('## 绑定项目');
+                    lines.push(`- 项目: ${project.name} (${project.projectId})`);
+                    if (project.description)
+                        lines.push(`- 描述: ${project.description}`);
+                    if (project.repos.length > 0) {
+                        lines.push(`- 仓库: ${project.repos.map(r => r.name).join(', ')}`);
+                    }
+                    if (project.claudeMd) {
+                        lines.push('- 技术栈:');
+                        lines.push(project.claudeMd);
+                    }
+                    lines.push('');
+                    lines.push('> 派发任务时，默认使用此项目的 project_id，无需用户额外指定。');
+                    lines.push('');
+                }
+            }
+            // 自定义上下文
+            if (chatCtx.custom_context) {
+                lines.push('## 自定义设定');
+                lines.push(chatCtx.custom_context);
+                lines.push('');
+            }
+            await writeFile(contextFile, lines.join('\n'), 'utf-8');
+            this.logger.info(`[SessionManager] 已写入 chat-context.md: ${chatId}`);
+        }
+        catch (err) {
+            this.logger.error(`[SessionManager] 写入 chat-context.md 失败 (${chatId}):`, err);
+        }
+    }
+    /**
+     * 从 DB 查找可 resume 的 CC session（程序重启后恢复）
+     * 返回最近一个未结束的 loid session_id，无则返回 undefined
+     */
+    findResumableSession(chatId) {
+        try {
+            const sessions = getCCSessionsByChat(this.deps.db, chatId);
+            const resumable = sessions.find(s => s.role === 'loid' && !s.ended_at);
+            if (resumable) {
+                this.logger.info(`[SessionManager] 发现可恢复 session: ${resumable.session_id} (chat=${chatId})`);
+                return resumable.session_id;
+            }
+        }
+        catch (err) {
+            this.logger.error('[SessionManager] 查询可恢复 session 失败:', err);
+        }
+        return undefined;
+    }
+    /**
+     * 获取活跃任务列表（用于崩溃恢复上下文）
+     */
+    getActiveTasks() {
+        const statuses = [
+            TaskStatus.IN_PROGRESS,
+            TaskStatus.READY,
+            TaskStatus.NEED_CLARIFICATION,
+            TaskStatus.DELIVERING,
+            TaskStatus.BLOCKED,
+        ];
+        const tasks = [];
+        for (const status of statuses) {
+            const statusTasks = getTasksByStatus(this.deps.db, status);
+            for (const t of statusTasks) {
+                tasks.push({
+                    task_id: t.task_id,
+                    title: t.title,
+                    status: t.status,
+                    assignee: t.assignee,
+                });
+            }
+        }
+        return tasks;
+    }
+}
+//# sourceMappingURL=session-manager.js.map