team-anya 0.2.0

package/apps/server/dist/franky/franky-orchestrator.js

@@ -0,0 +1,629 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { getTopic, getWorkspaceRecord, insertAuditEvent, insertCCSession, updateCCSessionEnded, getCCSessionsByTask, upsertTopic } from '@team-anya/db';
+import { FRANKY_DEFAULT_SCOPE } from '@team-anya/core';
+import { startFrankyMcpServer } from './franky-mcp-server.js';
+const execFile = promisify(execFileCb);
+// ── FrankyOrchestrator ──
+/**
+ * FrankyOrchestrator：话题协作者编排层
+ *
+ * 职责：
+ * - 管理每个 Topic 对应的 Franky CC 实例（最多一个）
+ * - 消息驱动：用户发消息时，实例存在则注入消息，不存在则自动创建
+ * - 监听 CC 实例的 result / exited / crash 事件
+ * - Idle 超时回收（预留接口，Phase 3 细化）
+ *
+ * 与 YorOrchestrator 的核心区别：
+ * - Yor：一次性任务执行（brief -> 执行 -> deliver -> 销毁）
+ * - Franky：持续协作（话题开启 -> 消息驱动对话 -> 话题关闭）
+ */
+export class FrankyOrchestrator {
+    broker;
+    config;
+    instances = new Map(); // key = topicId
+    spawning = new Map(); // 防止并发 spawn
+    logger;
+    idleCheckInterval = null;
+    idleTimeoutMs;
+    constructor(broker, config) {
+        this.broker = broker;
+        this.config = config;
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+        this.idleTimeoutMs = config.idleTimeoutMs ?? 30 * 60 * 1000; // 默认 30 分钟
+        // 启动 idle 检查定时器
+        this.idleCheckInterval = setInterval(() => this.checkIdleInstances(), 5 * 60 * 1000);
+        // 监听 CC session ID 事件（Franky 实例）
+        this.broker.on('instance.sessionId', (instanceId, cliSessionId) => {
+            const brokerInstance = this.broker.getInstance(instanceId);
+            if (brokerInstance?.role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                insertCCSession(this.config.db, {
+                    session_id: cliSessionId,
+                    role: 'franky',
+                    instance_id: instanceId,
+                    task_id: topicId,
+                    project_path: brokerInstance.config.workingDir,
+                });
+                this.logger.info(`[FrankyOrchestrator] 记录 CC session: ${cliSessionId} (topic: ${topicId})`);
+            }
+        });
+        // 监听 CC 实例事件
+        this.broker.on('instance.result', (instanceId, role, _result) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                const instance = this.instances.get(topicId);
+                if (instance)
+                    instance.lastActivityAt = new Date();
+                this.logger.info(`[FrankyOrchestrator] 实例 ${instanceId} 执行完成 (topic: ${topicId})`);
+            }
+        });
+        this.broker.on('instance.exited', (instanceId, role) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                // 更新 cc_sessions.ended_at
+                const brokerInstance = this.broker.getInstance(instanceId);
+                if (brokerInstance?.cliSessionId) {
+                    updateCCSessionEnded(this.config.db, brokerInstance.cliSessionId);
+                }
+                this.logger.info(`[FrankyOrchestrator] 实例 ${instanceId} 已退出 (topic: ${topicId})`);
+                this.cleanupInstance(topicId);
+            }
+        });
+        this.broker.on('instance.crash', (instanceId, role, error) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId) {
+                // 更新 cc_sessions.ended_at
+                const brokerInstance = this.broker.getInstance(instanceId);
+                if (brokerInstance?.cliSessionId) {
+                    updateCCSessionEnded(this.config.db, brokerInstance.cliSessionId);
+                }
+                this.logger.error(`[FrankyOrchestrator] 实例 ${instanceId} 崩溃 (topic: ${topicId}):`, error);
+                this.cleanupInstance(topicId);
+                // 通知外部（用于向用户发送崩溃提醒）
+                const topic = getTopic(this.config.db, topicId);
+                this.config.onCrash?.(topicId, topic?.title ?? topicId);
+            }
+        });
+        this.broker.on('instance.rate_limited', (instanceId, role, result) => {
+            if (role !== 'franky')
+                return;
+            const topicId = this.findTopicByInstanceId(instanceId);
+            if (topicId && result.rateLimitInfo) {
+                const topic = getTopic(this.config.db, topicId);
+                const topicTitle = topic?.title ?? topicId;
+                this.logger.info(`[FrankyOrchestrator] Franky 限流 (topic: ${topicId}): resetsAt=${result.rateLimitInfo.resetsAt}`);
+                this.config.onRateLimited?.(topicId, topicTitle, result.rateLimitInfo.resetsAt);
+            }
+        });
+    }
+    /**
+     * 向话题发送消息。
+     * - suspended 实例：尝试 resume，失败则 fallback 到全新 spawn
+     * - 不存在实例：全新 spawn
+     */
+    async sendMessage(topicId, message) {
+        let instance = this.instances.get(topicId);
+        if (instance?.suspended) {
+            // 挂起状态：尝试 resume
+            instance = await this.ensureInstance(topicId, () => this.resumeForTopic(topicId));
+        }
+        else if (!instance) {
+            // 完全不存在：全新 spawn
+            instance = await this.ensureInstance(topicId, () => this.spawnForTopic(topicId));
+        }
+        // 格式化用户消息为 prompt
+        const prompt = this.formatUserMessage(message);
+        // 注入消息到 CC 实例
+        try {
+            this.broker.sendPrompt(instance.instanceId, prompt);
+            instance.lastActivityAt = new Date();
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] 发送消息失败 (topic: ${topicId}):`, err);
+            // 实例可能已死，清理后重试一次
+            await this.cleanupInstance(topicId);
+            const newInstance = await this.spawnForTopic(topicId);
+            this.broker.sendPrompt(newInstance.instanceId, prompt);
+        }
+    }
+    /**
+     * 防并发 spawn/resume 包装
+     */
+    async ensureInstance(topicId, factory) {
+        let pending = this.spawning.get(topicId);
+        if (!pending) {
+            pending = factory();
+            this.spawning.set(topicId, pending);
+            try {
+                return await pending;
+            }
+            finally {
+                this.spawning.delete(topicId);
+            }
+        }
+        return pending;
+    }
+    /**
+     * 关闭指定 Topic 的 Franky 实例
+     */
+    async closeTopic(topicId) {
+        await this.cleanupInstance(topicId);
+        this.logger.info(`[FrankyOrchestrator] 关闭话题 ${topicId} 的 Franky 实例`);
+    }
+    /**
+     * 主动重启话题（/restart 命令）：完全清理，下次消息走全新 session + context 重建
+     */
+    async restartTopic(topicId) {
+        await this.cleanupInstance(topicId);
+        this.logger.info(`[FrankyOrchestrator] 话题 ${topicId} 已重启（全新 session）`);
+    }
+    /**
+     * 获取所有活跃的 Franky 实例状态
+     */
+    status() {
+        return [...this.instances.values()].map(i => ({
+            topicId: i.topicId,
+            instanceId: i.instanceId,
+            lastActivityAt: i.lastActivityAt.toISOString(),
+            ...(i.suspended ? { suspended: true } : {}),
+        }));
+    }
+    /**
+     * 优雅关闭所有实例
+     */
+    async shutdown() {
+        if (this.idleCheckInterval) {
+            clearInterval(this.idleCheckInterval);
+            this.idleCheckInterval = null;
+        }
+        const topicIds = [...this.instances.keys()];
+        for (const topicId of topicIds) {
+            await this.cleanupInstance(topicId);
+        }
+    }
+    // ── 私有方法 ──
+    /**
+     * Resume 挂起的 Franky 实例（复用之前的 CC session）
+     * 失败时自动 fallback 到全新 spawn
+     */
+    async resumeForTopic(topicId) {
+        const suspended = this.instances.get(topicId);
+        const savedSessionId = suspended?.savedCliSessionId;
+        if (!savedSessionId) {
+            this.logger.info(`[FrankyOrchestrator] 无可用 sessionId，fallback 到全新 spawn (topic: ${topicId})`);
+            this.instances.delete(topicId);
+            return this.spawnForTopic(topicId);
+        }
+        const topic = getTopic(this.config.db, topicId);
+        if (!topic)
+            throw new Error(`话题 ${topicId} 不存在`);
+        const instanceId = `franky:${topicId}`;
+        const topicWorkDir = topic.workspace_path;
+        if (!topicWorkDir || !existsSync(topicWorkDir)) {
+            this.logger.info(`[FrankyOrchestrator] 工作区不存在，fallback 到全新 spawn (topic: ${topicId})`);
+            this.instances.delete(topicId);
+            return this.spawnForTopic(topicId);
+        }
+        // 重新启动 MCP Server
+        const mcpServer = await this.startMcpServer(topicWorkDir, topicId, topic);
+        try {
+            const logFile = join(topicWorkDir, `cc-backend.log`);
+            await this.broker.spawn({
+                id: instanceId,
+                role: 'franky',
+                backendConfig: {
+                    type: 'claude-code',
+                    binary: this.config.binary,
+                    workingDir: topicWorkDir,
+                    permissionMode: 'bypassPermissions',
+                    resumeSessionId: savedSessionId,
+                    mcpServers: [{
+                            name: 'franky-tools',
+                            url: mcpServer.url,
+                            headers: { 'x-anya-internal': 'true' },
+                        }],
+                },
+                scope: FRANKY_DEFAULT_SCOPE,
+                mcpServer,
+                logFile,
+            });
+            // resume 成功：更新 instance
+            const instance = {
+                topicId,
+                instanceId,
+                mcpServer,
+                lastActivityAt: new Date(),
+            };
+            this.instances.set(topicId, instance);
+            this.logger.info(`[FrankyOrchestrator] Resume 成功 ${instanceId} (session: ${savedSessionId})`);
+            return instance;
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] Resume 失败，fallback 到全新 spawn (topic: ${topicId}):`, err);
+            await mcpServer.close().catch(() => { });
+            this.instances.delete(topicId);
+            return this.spawnForTopic(topicId);
+        }
+    }
+    /**
+     * 为指定 Topic 创建 Franky CC 实例
+     */
+    async spawnForTopic(topicId) {
+        const topic = getTopic(this.config.db, topicId);
+        if (!topic)
+            throw new Error(`话题 ${topicId} 不存在`);
+        const instanceId = `franky:${topicId}`;
+        // ── 准备工作区 ──
+        const hasExistingWorkspace = !!topic.workspace_id;
+        let topicWorkDir;
+        let repoInfo;
+        if (hasExistingWorkspace) {
+            // 从 escalate 而来：forkWorkspace 已创建独立 franky 工作区
+            const wsRecord = getWorkspaceRecord(this.config.db, topic.workspace_id);
+            if (!wsRecord)
+                throw new Error(`工作区 ${topic.workspace_id} 不存在`);
+            topicWorkDir = wsRecord.path;
+            this.logger.info(`[FrankyOrchestrator] 复用已有工作区 ${topicWorkDir} (topic: ${topicId})`);
+        }
+        else {
+            // 通过 WorkspaceManager 创建工作区（clone --local）
+            const wsResult = await this.prepareWorkspace(topic);
+            topicWorkDir = wsResult.workDir;
+            repoInfo = wsResult.repoInfo;
+            // 回写 workspace_path 和 branch_name 到 DB
+            if (wsResult.branchName) {
+                upsertTopic(this.config.db, {
+                    id: topic.id,
+                    title: topic.title,
+                    status: topic.status,
+                    description: topic.description ?? undefined,
+                    project_id: topic.project_id ?? undefined,
+                    thread_id: topic.thread_id ?? undefined,
+                    root_message_id: topic.root_message_id ?? undefined,
+                    chat_id: topic.chat_id ?? undefined,
+                    created_by: topic.created_by ?? undefined,
+                    workspace_path: topicWorkDir,
+                    branch_name: wsResult.branchName,
+                });
+            }
+        }
+        // 生成/重建 context.md
+        const contextPath = join(topicWorkDir, 'context.md');
+        const isRebuild = existsSync(contextPath);
+        // ── rebuild 模式：优先尝试从 DB 恢复上次 session（系统重启后仍可 resume）──
+        if (isRebuild) {
+            const lastSession = getCCSessionsByTask(this.config.db, topicId).find(s => !s.ended_at);
+            if (lastSession) {
+                this.logger.info(`[FrankyOrchestrator] 发现可恢复 session ${lastSession.session_id} (topic: ${topicId})`);
+                try {
+                    const mcpServer = await this.startMcpServer(topicWorkDir, topicId, topic);
+                    const logFile = join(topicWorkDir, `cc-backend.log`);
+                    await this.broker.spawn({
+                        id: instanceId,
+                        role: 'franky',
+                        backendConfig: {
+                            type: 'claude-code',
+                            binary: this.config.binary,
+                            workingDir: topicWorkDir,
+                            permissionMode: 'bypassPermissions',
+                            resumeSessionId: lastSession.session_id,
+                            mcpServers: [{
+                                    name: 'franky-tools',
+                                    url: mcpServer.url,
+                                    headers: { 'x-anya-internal': 'true' },
+                                }],
+                        },
+                        scope: FRANKY_DEFAULT_SCOPE,
+                        mcpServer,
+                        logFile,
+                    });
+                    const instance = { topicId, instanceId, mcpServer, lastActivityAt: new Date() };
+                    this.instances.set(topicId, instance);
+                    this.logger.info(`[FrankyOrchestrator] Resume 成功 ${instanceId} (session: ${lastSession.session_id})`);
+                    return instance;
+                }
+                catch (err) {
+                    this.logger.error(`[FrankyOrchestrator] Resume 失败，fallback 到全新 session:`, err);
+                    // 标记该 session 已结束，避免下次再尝试
+                    updateCCSessionEnded(this.config.db, lastSession.session_id);
+                }
+            }
+            // resume 失败或无可恢复 session：重建 context.md
+            try {
+                const { writeTopicContext } = await import('./context-builder.js');
+                await writeTopicContext({ db: this.config.db, workspacePath: topicWorkDir, logger: this.logger }, topicId);
+                this.logger.info(`[FrankyOrchestrator] 重建 context.md (topic: ${topicId})`);
+            }
+            catch (err) {
+                this.logger.error(`[FrankyOrchestrator] context.md 重建失败，使用现有文件:`, err);
+            }
+        }
+        else if (!hasExistingWorkspace) {
+            // 新建模式（非 escalate）：生成初始 context（含仓库信息）
+            await this.generateInitialContext(topic, contextPath, repoInfo);
+        }
+        // ── 全新 session 启动 ──
+        const mcpServer = await this.startMcpServer(topicWorkDir, topicId, topic);
+        // 准备启动 prompt（读取 context.md）
+        let startupPrompt;
+        try {
+            startupPrompt = await readFile(contextPath, 'utf-8');
+        }
+        catch {
+            startupPrompt = `# 话题: ${topic.title}\n\n目标: ${topic.description ?? '（未设定）'}`;
+        }
+        // 通过 CCBroker 启动实例
+        const logFile = join(topicWorkDir, `cc-backend.log`);
+        await this.broker.spawn({
+            id: instanceId,
+            role: 'franky',
+            backendConfig: {
+                type: 'claude-code',
+                binary: this.config.binary,
+                workingDir: topicWorkDir,
+                permissionMode: 'bypassPermissions',
+                mcpServers: [{
+                        name: 'franky-tools',
+                        url: mcpServer.url,
+                        headers: { 'x-anya-internal': 'true' },
+                    }],
+            },
+            scope: FRANKY_DEFAULT_SCOPE,
+            mcpServer,
+            logFile,
+        });
+        // 发送启动 prompt
+        this.broker.sendPrompt(instanceId, startupPrompt);
+        const instance = {
+            topicId,
+            instanceId,
+            mcpServer,
+            lastActivityAt: new Date(),
+        };
+        this.instances.set(topicId, instance);
+        insertAuditEvent(this.config.db, {
+            event_type: 'franky_spawned',
+            actor: 'system',
+            summary: `启动 Franky 实例: ${topicId}`,
+            detail: JSON.stringify({ instanceId, topicId }),
+        });
+        this.logger.info(`[FrankyOrchestrator] 启动 Franky 实例 ${instanceId} (topic: ${topicId})`);
+        return instance;
+    }
+    /**
+     * 通过 WorkspaceManager 创建工作区（clone --local 模式）
+     *
+     * - 调用 createWorkspace() 创建目录 + 角色文件 + DB 记录
+     * - 为每个 repo 调用 setupRepo() 执行 clone --local + 修正 remote + 创建分支
+     * - 初始化根目录 git（CC 需要 .git 作为项目边界）
+     */
+    async prepareWorkspace(topic) {
+        const wm = this.config.workspaceManager;
+        // 1. 创建工作区（含角色文件 + 共享文档）
+        const ws = await wm.createWorkspace({
+            role: 'franky',
+            ownerType: 'topic',
+            ownerId: topic.id,
+            projectId: topic.project_id,
+        });
+        const workDir = ws.path;
+        // 2. 如果关联了项目，为每个 repo 做 clone --local
+        if (!topic.project_id || !this.config.getProjectConfig) {
+            return { workDir };
+        }
+        let projectConfig;
+        try {
+            projectConfig = await this.config.getProjectConfig(topic.project_id);
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] 获取项目配置失败 (${topic.project_id}):`, err);
+            return { workDir };
+        }
+        if (projectConfig.mode !== 'project' || !projectConfig.repos?.length) {
+            return { workDir };
+        }
+        const branchName = topic.branch_name ?? `feat/topic-${topic.id}`;
+        const lines = ['## 代码工作区', ''];
+        for (const repo of projectConfig.repos) {
+            const gitUrl = repo.git_url;
+            if (!gitUrl) {
+                this.logger.error(`[FrankyOrchestrator] 仓库 "${repo.name}" 未配置 git_url，跳过`);
+                continue;
+            }
+            try {
+                await wm.setupRepo(ws.id, {
+                    repoName: repo.name,
+                    gitUrl,
+                    baseBranch: repo.default_branch ?? 'main',
+                    taskBranch: branchName,
+                    remoteUrl: gitUrl,
+                });
+                lines.push(`- \`${repo.name}/\` → 分支 \`${branchName}\`，路径 \`${join(workDir, repo.name)}\``);
+                this.logger.info(`[FrankyOrchestrator] 仓库已设置: ${repo.name} @ ${branchName}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.error(`[FrankyOrchestrator] 仓库 clone 失败 (${repo.name}): ${msg}`);
+                return { workDir };
+            }
+        }
+        // 3. git init 根目录（CC 需要 .git 作为项目边界）
+        try {
+            await execFile('git', ['init', workDir]);
+            const ignoreContent = projectConfig.repos.map(r => `/${r.name}/`).join('\n') + '\n';
+            await writeFile(join(workDir, '.gitignore'), ignoreContent, 'utf-8');
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] git init 失败:`, err);
+        }
+        lines.push('');
+        lines.push('> 代码在上述子目录中（独立 clone），git 操作请进入对应子目录执行。');
+        return { workDir, branchName, repoInfo: lines.join('\n') };
+    }
+    /**
+     * 启动 Franky MCP Server
+     */
+    async startMcpServer(topicWorkDir, topicId, topic) {
+        const mcpDeps = {
+            db: this.config.db,
+            workspacePath: topicWorkDir,
+            topicId,
+            replyToThreadId: topic.thread_id ?? undefined,
+            channelRegistry: this.config.channelRegistry,
+            onMessageSent: this.config.onMessageSent,
+            onTopicClosed: (tid) => this.closeTopic(tid),
+            onTopicEscalated: this.config.onTopicEscalated,
+            logger: this.logger,
+        };
+        return startFrankyMcpServer(mcpDeps);
+    }
+    /**
+     * 生成初始 context.md
+     */
+    async generateInitialContext(topic, contextPath, repoInfo) {
+        const lines = [
+            `# 话题上下文：${topic.title} (${topic.id})`,
+            '',
+            '## 目标',
+            topic.description ?? '（用户未设定详细描述）',
+            '',
+            '## 通讯信息',
+            ...(topic.chat_id ? [`- 群聊 ID：\`${topic.chat_id}\``] : []),
+            ...(topic.root_message_id ? [`- 话题根消息 ID：\`${topic.root_message_id}\``] : []),
+            ...(topic.thread_id ? [`- 话题 ID：\`${topic.thread_id}\`（仅供参考，channel.send 的 reply_to 请用根消息 ID）`] : []),
+            '',
+            '## 项目信息',
+            `- 话题 ID：${topic.id}`,
+            ...(topic.project_id ? [`- 关联项目：${topic.project_id}`] : []),
+            ...(topic.branch_name ? [`- 分支：${topic.branch_name}`] : []),
+            '',
+        ];
+        if (repoInfo) {
+            lines.push(repoInfo);
+            lines.push('');
+        }
+        await writeFile(contextPath, lines.join('\n'), 'utf-8');
+    }
+    /**
+     * 格式化用户消息为 CC prompt（包含结构化元信息）
+     */
+    formatUserMessage(message) {
+        const lines = [];
+        // 消息事件
+        const event = {
+            type: 'user_message',
+            time: message.metadata?.event_create_time ?? new Date().toISOString(),
+            sender_id: message.sender ?? '未知',
+            sender_name: message.senderName ?? null,
+            content: message.content,
+        };
+        if (message.metadata?.message_id) {
+            event.message_id = message.metadata.message_id;
+        }
+        if (message.metadata?.parent_message_id) {
+            event.reply_to = message.metadata.parent_message_id;
+        }
+        if (message.media.length > 0) {
+            event.media = message.media.map(m => ({
+                type: m.mediaType,
+                name: m.originalName,
+                path: m.localPath,
+            }));
+        }
+        lines.push(JSON.stringify(event, null, 2));
+        if (message.media.length > 0) {
+            lines.push('');
+            lines.push('提示: 本条消息包含媒体附件，你可以通过 media.path 中的本地路径读取文件内容（图片可直接查看，文件可读取文本）。');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 检查并回收空闲实例（挂起而非销毁，保留 resume 能力）
+     */
+    async checkIdleInstances() {
+        const now = Date.now();
+        for (const [topicId, instance] of this.instances) {
+            if (instance.suspended)
+                continue;
+            const idle = now - instance.lastActivityAt.getTime();
+            if (idle > this.idleTimeoutMs) {
+                this.logger.info(`[FrankyOrchestrator] 挂起空闲实例 ${instance.instanceId} (idle: ${Math.round(idle / 60000)}min)`);
+                await this.suspendInstance(topicId);
+            }
+        }
+    }
+    /**
+     * 挂起实例：释放进程资源但保留 sessionId 以便 resume
+     */
+    async suspendInstance(topicId) {
+        const instance = this.instances.get(topicId);
+        if (!instance || instance.suspended)
+            return;
+        // 从 broker 获取 cliSessionId 并保存
+        const brokerInstance = this.broker.getInstance(instance.instanceId);
+        if (brokerInstance?.cliSessionId) {
+            instance.savedCliSessionId = brokerInstance.cliSessionId;
+            updateCCSessionEnded(this.config.db, brokerInstance.cliSessionId);
+            this.logger.info(`[FrankyOrchestrator] 保存 sessionId ${brokerInstance.cliSessionId} (topic: ${topicId})`);
+        }
+        try {
+            await instance.mcpServer.close();
+        }
+        catch (err) {
+            this.logger.error(`[FrankyOrchestrator] MCP server 关闭失败:`, err);
+        }
+        try {
+            await this.broker.dispose(instance.instanceId);
+        }
+        catch {
+            // 可能已经退出
+        }
+        instance.suspended = true;
+    }
+    /**
+     * 完全清理实例（不保留 resume 信息）
+     */
+    async cleanupInstance(topicId) {
+        const instance = this.instances.get(topicId);
+        if (!instance)
+            return;
+        if (!instance.suspended) {
+            try {
+                await instance.mcpServer.close();
+            }
+            catch (err) {
+                this.logger.error(`[FrankyOrchestrator] MCP server 关闭失败:`, err);
+            }
+            try {
+                await this.broker.dispose(instance.instanceId);
+            }
+            catch {
+                // 可能已经退出
+            }
+        }
+        this.instances.delete(topicId);
+    }
+    /**
+     * 通过 instanceId 反查 topicId
+     */
+    findTopicByInstanceId(instanceId) {
+        for (const [topicId, instance] of this.instances) {
+            if (instance.instanceId === instanceId)
+                return topicId;
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=franky-orchestrator.js.map

package/apps/server/dist/franky/index.js

@@ -0,0 +1,5 @@
+export { FrankyOrchestrator } from './franky-orchestrator.js';
+export { startFrankyMcpServer } from './franky-mcp-server.js';
+export { FrankyTopicRouter } from './topic-router.js';
+export { buildTopicContext, writeTopicContext } from './context-builder.js';
+//# sourceMappingURL=index.js.map

package/apps/server/dist/franky/topic-router.js

@@ -0,0 +1,16 @@
+/**
+ * TopicRouter 实现：将消息路由给对应 Topic 的 Franky 实例
+ */
+export class FrankyTopicRouter {
+    orchestrator;
+    logger;
+    constructor(orchestrator, logger) {
+        this.orchestrator = orchestrator;
+        this.logger = logger ?? { info: console.log, error: console.error };
+    }
+    async routeToTopic(topicId, msg) {
+        this.logger.info(`[TopicRouter] 路由消息到话题 ${topicId}: ${msg.sender}`);
+        await this.orchestrator.sendMessage(topicId, msg);
+    }
+}
+//# sourceMappingURL=topic-router.js.map