team-anya 0.2.0

package/apps/server/dist/main.js

@@ -0,0 +1,528 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import Fastify from 'fastify';
+import fastifyCors from '@fastify/cors';
+import fastifyStatic from '@fastify/static';
+import { createDB, getTask as dbGetTask, getTopic as dbGetTopic } from '@team-anya/db';
+import { memoryRemember, auditAppend, ChannelRegistry, FeishuAdapter } from '@team-anya/mcp-tools';
+import { ensureOffice, ensureWorkspacesDir, TaskStatus, RepoCache, WorkspaceManager } from '@team-anya/core';
+import { createWorkspaceRecord, getWorkspaceRecord, updateWorkspaceRecord, getWorkspaceByOwner } from '@team-anya/db';
+import { loadConfig } from './config.js';
+import { registerRoutes } from './gateway/http.js';
+import { CCBroker } from './broker/cc-broker.js';
+import { YorOrchestrator } from './yor/yor-orchestrator.js';
+import { FeishuWSClient } from './gateway/feishu-ws.js';
+import { MediaDownloader } from './gateway/media-downloader.js';
+import { ChatSyncService } from './gateway/chat-sync.js';
+import { FeishuSender } from './gateway/feishu-sender.js';
+import { MessageIntake } from './gateway/message-intake.js';
+import { CommandRouter } from './gateway/command-router.js';
+import { registerBuiltinCommands } from './gateway/commands/index.js';
+import { MessageQueue } from './gateway/message-queue.js';
+import { MemorySettler } from './loid/memory-settler.js';
+import { LoidBrain } from './loid/brain.js';
+import { LoidContextBuilder } from './loid/context-builder.js';
+import { Clarifier } from './loid/clarifier.js';
+import { ProjectRegistry } from './loid/project-registry.js';
+import { FrankyOrchestrator } from './franky/franky-orchestrator.js';
+import { FrankyTopicRouter } from './franky/topic-router.js';
+import { HealthMonitor } from './gateway/health-monitor.js';
+export async function buildServer() {
+    const config = loadConfig();
+    // 初始化 office 目录（从模板源复制缺失的文件）
+    await ensureOffice(config.WORKSPACE_PATH, resolve(config.OFFICE_TEMPLATE_DIR), { info: (msg) => console.log(`[office-init] ${msg}`) });
+    const db = createDB(config.SQLITE_PATH);
+    // 日志配置：stdout + 文件双写（按日期+大小分割）
+    let loggerConfig = false;
+    if (config.NODE_ENV !== 'test') {
+        const logDir = resolve(config.LOG_DIR);
+        mkdirSync(logDir, { recursive: true });
+        loggerConfig = {
+            level: 'info',
+            transport: {
+                targets: [
+                    { target: 'pino-pretty', options: { destination: 1 }, level: 'info' },
+                    {
+                        target: 'pino-roll',
+                        options: {
+                            file: join(logDir, 'anya'),
+                            frequency: 'daily',
+                            limit: { count: 14 },
+                            mkdir: true,
+                        },
+                        level: 'info',
+                    },
+                ],
+            },
+        };
+    }
+    const app = Fastify({
+        logger: loggerConfig,
+        disableRequestLogging: true,
+    });
+    // CORS
+    if (config.NODE_ENV === 'development') {
+        await app.register(fastifyCors, { origin: 'http://localhost:5173' });
+    }
+    // 静态文件（兼容 monorepo 开发 + npm 全局安装两种目录结构）
+    const webDistCandidates = [
+        resolve(import.meta.dirname, '../../web/dist'), // npm 包: apps/server/dist/ → apps/web/dist/
+        resolve(import.meta.dirname, '../../../apps/web/dist'), // monorepo 开发: src/ 下通过 tsx 运行
+    ];
+    const webDistPath = webDistCandidates.find(p => existsSync(p)) ?? webDistCandidates[0];
+    const serveStatic = config.NODE_ENV !== 'test' && existsSync(webDistPath);
+    if (serveStatic) {
+        await app.register(fastifyStatic, {
+            root: webDistPath,
+            prefix: '/',
+        });
+    }
+    // FeishuSender + 共享 Lark Client
+    let larkClient;
+    const feishuSender = (config.FEISHU_APP_ID && config.FEISHU_APP_SECRET)
+        ? new FeishuSender({ appId: config.FEISHU_APP_ID, appSecret: config.FEISHU_APP_SECRET, db })
+        : null;
+    if (config.FEISHU_APP_ID && config.FEISHU_APP_SECRET) {
+        const Lark = await import('@larksuiteoapi/node-sdk');
+        larkClient = new Lark.Client({
+            appId: config.FEISHU_APP_ID,
+            appSecret: config.FEISHU_APP_SECRET,
+        });
+    }
+    // ChatSyncService（飞书群信息同步）
+    const chatSyncService = larkClient ? new ChatSyncService(larkClient, db) : null;
+    // ChannelRegistry（通道注册表）
+    const channelRegistry = new ChannelRegistry();
+    if (feishuSender) {
+        channelRegistry.register(new FeishuAdapter(feishuSender));
+        app.log.info('已注册飞书通道适配器');
+    }
+    // MemorySettler
+    const memorySettler = new MemorySettler({
+        readFile: async (path) => {
+            try {
+                return await readFile(path, 'utf-8');
+            }
+            catch {
+                return null;
+            }
+        },
+        memoryRemember: (input) => memoryRemember(db, config.WORKSPACE_PATH, input),
+        auditAppend: (input) => auditAppend(db, config.WORKSPACE_PATH, input).then(() => { }),
+    });
+    // 任务完成后处理回调
+    const onTaskComplete = async (taskId, exitCode) => {
+        if (exitCode !== 0)
+            return;
+        try {
+            const taskDir = join(config.WORKSPACE_PATH, 'yor', 'tasks', taskId);
+            await memorySettler.settle(taskId, taskDir);
+        }
+        catch (err) {
+            console.error('经验沉淀失败:', err);
+        }
+    };
+    // Clarifier（保留用于 HTTP API）
+    const clarifier = new Clarifier({ db });
+    // ProjectRegistry — 项目注册表
+    const projectRegistry = new ProjectRegistry({
+        workspacePath: resolve(config.WORKSPACE_PATH),
+        projectsConfigPath: resolve(config.PROJECTS_CONFIG_PATH),
+        reposPath: resolve(config.REPOS_PATH),
+        db,
+    });
+    // 自动初始化仓库（首次使用时 clone 缺失的仓库）
+    const ensureResult = await projectRegistry.ensureRepos();
+    if (ensureResult.cloned.length > 0) {
+        app.log.info(`自动 clone 仓库: ${ensureResult.cloned.join(', ')}`);
+    }
+    if (ensureResult.failed.length > 0) {
+        for (const f of ensureResult.failed) {
+            app.log.error(`仓库初始化失败 (${f.name}): ${f.error}`);
+        }
+    }
+    // WorkspaceManager（clone-based 工作区管理）
+    await ensureWorkspacesDir(config.ANYA_HOME, resolve(config.OFFICE_TEMPLATE_DIR), { info: (msg) => console.log(`[office-init] ${msg}`) });
+    const repoCache = new RepoCache({
+        reposPath: resolve(config.REPOS_PATH),
+        logger: { info: (msg) => app.log.info(msg) },
+    });
+    const workspaceStore = {
+        create: (data) => createWorkspaceRecord(db, data),
+        get: (id) => getWorkspaceRecord(db, id),
+        update: (id, data) => updateWorkspaceRecord(db, id, data),
+        findByOwner: (ownerId) => getWorkspaceByOwner(db, ownerId),
+    };
+    const workspaceManager = new WorkspaceManager(workspaceStore, {
+        workspacesPath: resolve(config.WORKSPACES_PATH),
+        templateDir: resolve(config.OFFICE_TEMPLATE_DIR),
+        logger: { info: (msg) => app.log.info(msg) },
+    }, repoCache);
+    // ContextBuilder
+    const contextBuilder = new LoidContextBuilder({
+        db,
+        workspacePath: config.WORKSPACE_PATH,
+        projectRegistry,
+    });
+    // CCBroker — 统一 CC 进程管理器
+    const broker = new CCBroker({
+        maxLoidInstances: 2,
+        maxYorInstances: config.MAX_YOR_CONCURRENCY,
+        maxFrankyInstances: 2,
+        logger: app.log,
+    });
+    // YorOrchestrator — 替代 Yor 子进程，通过 CCBroker 管理 Yor CC
+    const yorOrchestrator = new YorOrchestrator(broker, {
+        binary: config.CLAUDE_CODE_BINARY,
+        workspacePath: config.WORKSPACE_PATH,
+        db,
+        logger: app.log,
+    });
+    // ── Franky Orchestrator ──
+    const frankyOrchestrator = new FrankyOrchestrator(broker, {
+        binary: config.CLAUDE_CODE_BINARY,
+        workspacePath: config.WORKSPACE_PATH,
+        db,
+        channelRegistry,
+        workspaceManager,
+        onMessageSent: feishuSender
+            ? (chatId) => { feishuSender.clearTypingReaction(chatId).catch(() => { }); }
+            : undefined,
+        onTopicEscalated: (topicId, reason, category) => {
+            // 通过飞书通知让相关人感知升级事件（审计日志已由 topic.escalate 工具写入）
+            if (feishuSender) {
+                const topic = dbGetTopic(db, topicId);
+                const chatId = topic?.chat_id;
+                if (chatId) {
+                    feishuSender.sendText({
+                        receiveIdType: 'chat_id',
+                        receiveId: chatId,
+                        text: `[Franky 升级] 话题「${topic?.title ?? topicId}」需要介入（${category}）：${reason}`,
+                    }).catch(err => {
+                        app.log.error({ err, topicId }, 'Franky 升级飞书通知发送失败');
+                    });
+                }
+            }
+            app.log.info({ topicId, category, reason }, 'Franky 升级请求');
+        },
+        onRateLimited: (topicId, topicTitle, resetsAt) => {
+            app.log.info({ topicId, resetsAt }, 'Franky 实例限流');
+            if (feishuSender) {
+                const topic = dbGetTopic(db, topicId);
+                const chatId = topic?.chat_id;
+                if (chatId) {
+                    const resetTime = new Date(resetsAt * 1000).toLocaleTimeString('zh-CN', {
+                        hour: '2-digit', minute: '2-digit', timeZone: 'Asia/Shanghai',
+                    });
+                    feishuSender.sendText({
+                        receiveIdType: 'chat_id',
+                        receiveId: chatId,
+                        text: `🙋 Franky 请假通知\nFranky 在「${topicTitle}」话题中聊得太投入，需要喘口气。预计 ${resetTime} 回来继续。`,
+                    }).catch(err => {
+                        app.log.error({ err, topicId }, 'Franky 限流通知发送失败');
+                    });
+                }
+            }
+        },
+        onCrash: (topicId, topicTitle) => {
+            app.log.error({ topicId }, 'Franky 实例崩溃');
+            if (feishuSender) {
+                const topic = dbGetTopic(db, topicId);
+                const chatId = topic?.chat_id;
+                if (chatId) {
+                    const replies = [
+                        '不好意思，刚才掉线了，你再说一下我接上',
+                        '抱歉断了一下，你可以继续说，我会重新接上的',
+                        '出了点小状况，不过没事，你继续说就行',
+                    ];
+                    feishuSender.sendText({
+                        receiveIdType: 'chat_id',
+                        receiveId: chatId,
+                        text: replies[Math.floor(Math.random() * replies.length)],
+                    }).catch(err => {
+                        app.log.error({ err, topicId }, 'Franky 崩溃通知发送失败');
+                    });
+                }
+            }
+        },
+        getProjectConfig: (projectId) => projectRegistry.getProjectConfig(projectId),
+        logger: app.log,
+    });
+    const topicRouter = new FrankyTopicRouter(frankyOrchestrator, app.log);
+    // LoidBrain（指挥模式）
+    const loidBrain = new LoidBrain({
+        binary: config.CLAUDE_CODE_BINARY,
+        loidBaseDir: resolve(config.LOID_BASE_DIR),
+        officePath: resolve(config.WORKSPACE_PATH),
+        templateDir: resolve(config.OFFICE_TEMPLATE_DIR),
+        protocolsDir: resolve(config.LOID_PROTOCOLS_DIR),
+        maxTurnsPerSession: 50,
+        logger: app.log,
+    }, {
+        broker,
+        feishuSender: feishuSender ?? undefined,
+        projectRegistry,
+        mcpDeps: {
+            db,
+            channelRegistry,
+            workspacePath: config.WORKSPACE_PATH,
+            logger: app.log,
+            yorOrchestrator,
+            threadCreator: feishuSender ?? undefined,
+            getProjectConfig: (projectId) => projectRegistry.getProjectConfig(projectId),
+            onProjectChanged: () => projectRegistry.invalidateCache(),
+            workspaceManager,
+            onMessageSent: feishuSender
+                ? (chatId) => { feishuSender.clearTypingReaction(chatId).catch(() => { }); }
+                : undefined,
+            onTaskEscalated: (topicId, workspacePath, followUpMessage) => {
+                app.log.info({ topicId, workspacePath, hasFollowUp: !!followUpMessage }, '任务已升级为话题');
+                if (followUpMessage) {
+                    // 立即启动 Franky 并转发用户的续做请求
+                    frankyOrchestrator.sendMessage(topicId, {
+                        content: followUpMessage,
+                        media: [],
+                        isDirectMessage: false,
+                        mentionsAnya: true,
+                    }).catch(err => {
+                        app.log.error({ topicId, err: err instanceof Error ? err.message : String(err) }, '启动 Franky 处理续做请求失败');
+                    });
+                }
+            },
+        },
+    });
+    await loidBrain.init();
+    app.log.info('LoidBrain (指挥模式) 已启动');
+    // YorOrchestrator 回调 → 状态变更 + 通知 LoidBrain
+    yorOrchestrator.setCallbacks({
+        onDelivery: (taskId, _data) => {
+            // IN_PROGRESS → DELIVERING
+            yorOrchestrator.transitionTask(taskId, TaskStatus.DELIVERING, 'yor', 'Yor 提交交付');
+            const ctx = contextBuilder.buildDeliveryContext(taskId, 0);
+            loidBrain.handleDelivery(ctx).catch(err => {
+                app.log.error({ err, taskId }, 'Yor 交付验收触发失败');
+            });
+        },
+        onBlocker: (taskId, data) => {
+            // IN_PROGRESS → BLOCKED
+            yorOrchestrator.transitionTask(taskId, TaskStatus.BLOCKED, 'yor', `阻塞: ${data.category} - ${data.reason}`);
+            app.log.info({ taskId, category: data.category }, 'Yor 报告阻塞，已更新状态');
+        },
+        onInstanceExited: (taskId) => {
+            onTaskComplete(taskId, 0).catch(err => {
+                app.log.error({ err, taskId }, '经验沉淀失败');
+            });
+        },
+        onRateLimited: (taskId, resetsAt, _rateLimitType) => {
+            app.log.info({ taskId, resetsAt }, 'Yor 实例限流');
+            if (feishuSender) {
+                const task = dbGetTask(db, taskId);
+                const chatId = task?.source_chat_id;
+                if (chatId) {
+                    const title = task?.title ? `「${task.title}」` : taskId;
+                    const resetTime = new Date(resetsAt * 1000).toLocaleTimeString('zh-CN', {
+                        hour: '2-digit', minute: '2-digit', timeZone: 'Asia/Shanghai',
+                    });
+                    feishuSender.sendText({
+                        receiveIdType: 'chat_id',
+                        receiveId: chatId,
+                        text: `🙋 Yor 请假通知\n${title} 执行过程中体力不支了，需要休息一下。预计 ${resetTime} 回来继续干活，任务已自动挂起，不用担心。`,
+                    }).catch(err => {
+                        app.log.error({ err, taskId }, 'Yor 限流通知发送失败');
+                    });
+                }
+            }
+        },
+        onInstanceCrash: (taskId, error) => {
+            app.log.error({ taskId, error }, 'Yor 实例崩溃');
+            // 崩溃 → BLOCKED（非终态才变更）
+            yorOrchestrator.transitionTask(taskId, TaskStatus.BLOCKED, 'system', `Yor 实例崩溃: ${error}`);
+            // 通知用户：任务执行遇到问题
+            if (feishuSender) {
+                const task = dbGetTask(db, taskId);
+                const chatId = task?.source_chat_id;
+                if (chatId) {
+                    const title = task?.title ? `「${task.title}」` : taskId;
+                    feishuSender.sendText({
+                        receiveIdType: 'chat_id',
+                        receiveId: chatId,
+                        text: `${title} 执行过程中出了点问题，我先看看怎么回事`,
+                    }).catch(err => {
+                        app.log.error({ err, taskId }, 'Yor 崩溃通知发送失败');
+                    });
+                }
+            }
+            const ctx = contextBuilder.buildDeliveryContext(taskId, 1);
+            loidBrain.handleDelivery(ctx).catch(err => {
+                app.log.error({ err, taskId }, 'Yor 崩溃后验收触发失败');
+            });
+        },
+    });
+    // 重启回调：释放 Loid 会话 + Broker 全部实例
+    const onRestart = async () => {
+        // 先让 SessionManager 清理 session map（会同时 dispose broker 中的 Loid 实例）
+        if (loidBrain) {
+            await loidBrain.disposeSessions();
+        }
+        // 再释放剩余实例（Yor 等）
+        const ids = await broker.disposeAll();
+        app.log.info(`[restart] 已释放 ${ids.length} 个 CC 实例`);
+        return { disposed: ids.length };
+    };
+    // CommandRouter（斜杠命令拦截）
+    let commandRouter;
+    if (feishuSender) {
+        commandRouter = new CommandRouter({ db, feishuSender, broker, onRestart, frankyOrchestrator, loidSessionManager: loidBrain, logger: app.log });
+        registerBuiltinCommands(commandRouter);
+        app.log.info('CommandRouter 已注册内置命令');
+    }
+    // MessageIntake（事件转发器）
+    const messageIntake = new MessageIntake({
+        db,
+        loidBrain,
+        contextBuilder,
+        commandRouter,
+        topicRouter,
+    });
+    // MessageQueue
+    const messageQueue = new MessageQueue({
+        handler: async (msg) => {
+            try {
+                await messageIntake.handle(msg);
+            }
+            catch (err) {
+                app.log.error({ err, msg: msg.content.slice(0, 50) }, '消息处理失败');
+            }
+        },
+        logger: {
+            info: (...args) => app.log.info(args.join(' ')),
+            warn: (...args) => app.log.warn(args.join(' ')),
+            error: (...args) => app.log.error(args.join(' ')),
+        },
+    });
+    // HTTP 路由
+    await registerRoutes(app, { db, broker, clarifier, messageQueue, larkClient, chatSyncService, onRestart });
+    // SPA fallback
+    if (serveStatic) {
+        app.setNotFoundHandler(async (request, reply) => {
+            if (request.url.startsWith('/api/')) {
+                return reply.status(404).send({ error: 'Not Found' });
+            }
+            return reply.sendFile('index.html', webDistPath);
+        });
+    }
+    // ── HealthMonitor（静默健康监控）──
+    let healthMonitor = null;
+    if (feishuSender) {
+        healthMonitor = new HealthMonitor({
+            broker,
+            db,
+            feishuSender,
+            resolveChatId: (instanceId, role) => {
+                if (role === 'loid') {
+                    // instanceId 格式: loid:${chatId} 或 loid:delivery:${taskId}
+                    const key = instanceId.replace(/^loid:/, '');
+                    if (key.startsWith('delivery:'))
+                        return null; // 内部 session，不通知
+                    return key;
+                }
+                if (role === 'yor') {
+                    const instance = broker.getInstance(instanceId);
+                    if (instance?.taskId) {
+                        const task = dbGetTask(db, instance.taskId);
+                        return task?.source_chat_id ?? null;
+                    }
+                    return null;
+                }
+                if (role === 'franky') {
+                    // instanceId 格式: franky:${topicId}
+                    const topicId = instanceId.replace(/^franky:/, '');
+                    const topic = dbGetTopic(db, topicId);
+                    return topic?.chat_id ?? null;
+                }
+                return null;
+            },
+            logger: app.log,
+        });
+        healthMonitor.start();
+        app.log.info('HealthMonitor 已启动');
+    }
+    return { app, db, config, broker, yorOrchestrator, frankyOrchestrator, messageIntake, messageQueue, feishuSender, loidBrain, larkClient, chatSyncService, healthMonitor };
+}
+/**
+ * 完整启动流程：buildServer + listen + 飞书 WS + graceful shutdown
+ * CLI 和直接运行都调用这个函数
+ */
+export async function startServer() {
+    const serverCtx = await buildServer();
+    const { app, config, broker, messageQueue, feishuSender, loidBrain, larkClient, chatSyncService, db, frankyOrchestrator, healthMonitor } = serverCtx;
+    await app.listen({ port: config.PORT, host: '0.0.0.0' });
+    app.log.info(`Anya server 已启动，端口 ${config.PORT}`);
+    // 飞书 WebSocket 长连接
+    let feishuWs = null;
+    if (config.FEISHU_APP_ID && config.FEISHU_APP_SECRET && larkClient) {
+        const mediaDownloader = new MediaDownloader(larkClient, {
+            mediaDir: config.MEDIA_PATH,
+        });
+        await mediaDownloader.ensureDir();
+        feishuWs = new FeishuWSClient({ appId: config.FEISHU_APP_ID, appSecret: config.FEISHU_APP_SECRET }, {
+            onMessage: async (msg) => {
+                messageQueue.enqueue(msg);
+            },
+            mediaDownloader,
+            client: larkClient,
+            db,
+            chatSyncService: chatSyncService ?? undefined,
+            feishuSender: feishuSender ?? undefined,
+            logger: app.log,
+        });
+        feishuWs.connect().then(() => {
+            app.log.info('飞书 WebSocket 连接已建立');
+        }).catch((err) => {
+            app.log.error({ err }, '飞书 WebSocket 连接失败');
+        });
+    }
+    else {
+        app.log.info('飞书凭证未配置，跳过 WebSocket 连接');
+    }
+    // ── Graceful shutdown ──
+    let shuttingDown = false;
+    const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        app.log.info(`收到 ${signal}，开始优雅关闭...`);
+        if (feishuWs)
+            await feishuWs.close();
+        healthMonitor?.stop();
+        messageQueue.dispose();
+        await app.close();
+        if (loidBrain) {
+            try {
+                await loidBrain.dispose();
+            }
+            catch (err) {
+                app.log.error({ err }, 'LoidBrain 关闭失败');
+            }
+        }
+        await frankyOrchestrator.shutdown();
+        const result = await broker.shutdown(30_000);
+        if (result.unfinished.length > 0) {
+            app.log.info(`优雅关闭: ${result.unfinished.length} 个实例未完成`);
+        }
+        app.log.info('Anya server 已关闭');
+    };
+    process.on('SIGINT', () => { shutdown('SIGINT').then(() => process.exit(0)); });
+    process.on('SIGTERM', () => { shutdown('SIGTERM').then(() => process.exit(0)); });
+    return { app, config };
+}
+// 仅在直接运行时启动
+const isDirectRun = process.argv[1]?.endsWith('main.js') || process.argv[1]?.endsWith('main.ts');
+if (isDirectRun) {
+    startServer().catch((err) => {
+        console.error('启动失败:', err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=main.js.map

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

@@ -0,0 +1,2 @@
+export { TraceContext } from './trace-context.js';
+//# sourceMappingURL=index.js.map

package/apps/server/dist/tracing/trace-context.js

@@ -0,0 +1,92 @@
+import { randomUUID } from 'node:crypto';
+import { insertTraceSpan, updateTraceSpan } from '@team-anya/db';
+export class TraceContext {
+    traceId;
+    db;
+    logger;
+    spanStack = [];
+    constructor(config, traceId) {
+        this.traceId = traceId ?? randomUUID();
+        this.db = config.db;
+        this.logger = config.logger;
+    }
+    startSpan(operation, input) {
+        const spanId = randomUUID();
+        const parentSpanId = this.spanStack.length > 0
+            ? this.spanStack[this.spanStack.length - 1].spanId
+            : null;
+        this.spanStack.push({ spanId, operation, startedAt: Date.now() });
+        // Fire-and-forget DB write
+        try {
+            insertTraceSpan(this.db, {
+                trace_id: this.traceId,
+                span_id: spanId,
+                parent_span_id: parentSpanId,
+                operation,
+                status: 'in_progress',
+                started_at: new Date().toISOString(),
+                input: input !== undefined ? JSON.stringify(input) : null,
+            });
+        }
+        catch (err) {
+            this.logger?.error('TraceContext: insertTraceSpan 失败', err);
+        }
+        return spanId;
+    }
+    endSpan(opts) {
+        const targetSpanId = opts?.spanId;
+        let entry;
+        if (targetSpanId) {
+            // Find and remove the specific span from the stack
+            const idx = this.spanStack.findIndex(s => s.spanId === targetSpanId);
+            if (idx >= 0) {
+                entry = this.spanStack[idx];
+                this.spanStack.splice(idx, 1);
+            }
+        }
+        else {
+            // Pop the top of the stack
+            entry = this.spanStack.pop();
+        }
+        if (!entry) {
+            this.logger?.error('TraceContext: endSpan 未找到对应 span');
+            return;
+        }
+        const endedAt = Date.now();
+        const durationMs = endedAt - entry.startedAt;
+        try {
+            updateTraceSpan(this.db, entry.spanId, {
+                status: opts?.status ?? 'success',
+                ended_at: new Date().toISOString(),
+                duration_ms: durationMs,
+                output: opts?.output !== undefined ? JSON.stringify(opts.output) : null,
+                error: opts?.error ?? null,
+                metadata: opts?.metadata ? JSON.stringify(opts.metadata) : null,
+            });
+        }
+        catch (err) {
+            this.logger?.error('TraceContext: updateTraceSpan 失败', err);
+        }
+    }
+    async withSpan(operation, input, fn) {
+        const spanId = this.startSpan(operation, input);
+        try {
+            const result = await fn();
+            this.endSpan({
+                spanId,
+                status: 'success',
+                output: result,
+            });
+            return result;
+        }
+        catch (err) {
+            this.endSpan({
+                spanId,
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            });
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=trace-context.js.map

package/apps/server/dist/types/message.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=message.js.map