team-anya-cli 0.1.0

package/apps/server/dist/main.js

@@ -0,0 +1,337 @@
+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 } from '@team-anya/db';
+import { memoryRemember, auditAppend, ChannelRegistry, FeishuAdapter } from '@team-anya/mcp-tools';
+import { ensureOffice, TaskStatus } from '@team-anya/core';
+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 { WorktreeManager } from './loid/worktree-manager.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 });
+    // WorktreeManager
+    const worktreeManager = new WorktreeManager({
+        workspacePath: resolve(config.WORKSPACE_PATH),
+        projectsConfigPath: resolve(config.PROJECTS_CONFIG_PATH),
+        reposPath: resolve(config.REPOS_PATH),
+        db,
+    });
+    // 自动初始化仓库（首次使用时 clone 缺失的仓库）
+    const ensureResult = await worktreeManager.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}`);
+        }
+    }
+    // ContextBuilder
+    const contextBuilder = new LoidContextBuilder({
+        db,
+        workspacePath: config.WORKSPACE_PATH,
+        worktreeManager,
+    });
+    // CCBroker — 统一 CC 进程管理器
+    const broker = new CCBroker({
+        maxLoidInstances: 2,
+        maxYorInstances: config.MAX_YOR_CONCURRENCY,
+        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,
+    });
+    // LoidBrain（指挥模式）
+    const loidBrain = new LoidBrain({
+        binary: config.CLAUDE_CODE_BINARY,
+        loidWorkDir: resolve(config.LOID_WORK_DIR),
+        protocolsDir: resolve(config.LOID_PROTOCOLS_DIR),
+        maxTurnsPerSession: 50,
+        logger: app.log,
+    }, {
+        broker,
+        mcpDeps: {
+            db,
+            channelRegistry,
+            workspacePath: config.WORKSPACE_PATH,
+            logger: app.log,
+            yorOrchestrator,
+            getProjectConfig: (projectId) => worktreeManager.getProjectConfig(projectId),
+        },
+    });
+    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 }, '经验沉淀失败');
+            });
+        },
+        onInstanceCrash: (taskId, error) => {
+            app.log.error({ taskId, error }, 'Yor 实例崩溃');
+            // 崩溃 → BLOCKED（非终态才变更）
+            yorOrchestrator.transitionTask(taskId, TaskStatus.BLOCKED, 'system', `Yor 实例崩溃: ${error}`);
+            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, logger: app.log });
+        registerBuiltinCommands(commandRouter);
+        app.log.info('CommandRouter 已注册内置命令');
+    }
+    // MessageIntake（事件转发器）
+    const messageIntake = new MessageIntake({
+        db,
+        loidBrain,
+        contextBuilder,
+        commandRouter,
+    });
+    // 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);
+        });
+    }
+    return { app, db, config, broker, yorOrchestrator, messageIntake, messageQueue, feishuSender, loidBrain, larkClient, chatSyncService };
+}
+/**
+ * 完整启动流程：buildServer + listen + 飞书 WS + graceful shutdown
+ * CLI 和直接运行都调用这个函数
+ */
+export async function startServer() {
+    const serverCtx = await buildServer();
+    const { app, config, broker, messageQueue, feishuSender, loidBrain, larkClient, chatSyncService, db } = 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();
+        messageQueue.dispose();
+        await app.close();
+        if (loidBrain) {
+            try {
+                await loidBrain.dispose();
+            }
+            catch (err) {
+                app.log.error({ err }, 'LoidBrain 关闭失败');
+            }
+        }
+        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

package/apps/server/dist/yor/yor-mcp-server.js

@@ -0,0 +1,104 @@
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { Server } from '@modelcontextprotocol/sdk/server';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { createToolRouter } from '@team-anya/mcp-tools';
+// ── MCP Server 创建（薄路由层） ──
+function createYorMcpServer(deps) {
+    const logger = deps.collector.logger ?? { info: console.log, error: console.error };
+    const routerDeps = {
+        db: deps.db,
+        workspacePath: deps.workspacePath,
+        currentTaskId: deps.currentTaskId,
+        yorCollector: deps.collector,
+        logger,
+    };
+    const router = createToolRouter('yor', routerDeps);
+    const server = new Server({ name: 'yor-mcp', version: '2.0.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = router.tools.map(def => ({
+            name: def.name,
+            description: def.description,
+            inputSchema: zodToJsonSchema(def.inputSchema),
+        }));
+        return { tools };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        return router.handleToolCall(name, args ?? {});
+    });
+    return server;
+}
+/**
+ * 启动 Yor MCP server（薄路由层）
+ *
+ * Yor 现在可以使用 Layer 1 全部共享工具（memory/org/task.get/audit）
+ * + Layer 2 Yor 专属工具（task.deliver/task.block/task.progress）。
+ *
+ * 所有工具实现来自 @team-anya/mcp-tools。
+ */
+export async function startYorMcpServer(deps) {
+    const sessions = new Map();
+    const httpServer = createServer(async (req, res) => {
+        const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        if (url.pathname !== '/mcp') {
+            res.writeHead(404);
+            res.end('Not Found');
+            return;
+        }
+        const sessionId = req.headers['mcp-session-id'];
+        if (sessionId && sessions.has(sessionId)) {
+            const { transport } = sessions.get(sessionId);
+            await transport.handleRequest(req, res);
+            return;
+        }
+        if (req.method === 'POST') {
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+            });
+            const server = createYorMcpServer(deps);
+            transport.onclose = () => {
+                if (transport.sessionId) {
+                    sessions.delete(transport.sessionId);
+                }
+                // 不在这里调用 server.close()，避免与 close() 函数形成循环调用导致栈溢出
+            };
+            await server.connect(transport);
+            await transport.handleRequest(req, res);
+            if (transport.sessionId) {
+                sessions.set(transport.sessionId, { server, transport });
+            }
+            return;
+        }
+        res.writeHead(400);
+        res.end('Bad Request: No valid session');
+    });
+    await new Promise((resolve) => {
+        httpServer.listen(0, '127.0.0.1', resolve);
+    });
+    const addr = httpServer.address();
+    const port = typeof addr === 'object' && addr !== null ? addr.port : 0;
+    const serverUrl = `http://127.0.0.1:${port}/mcp`;
+    return {
+        port,
+        url: serverUrl,
+        close: async () => {
+            for (const { server, transport } of sessions.values()) {
+                await transport.close();
+                await server.close();
+            }
+            sessions.clear();
+            await new Promise((resolve, reject) => {
+                httpServer.close((err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=yor-mcp-server.js.map