team-anya-cli 0.1.0

package/apps/server/dist/gateway/media-downloader.js

@@ -0,0 +1,149 @@
+import { writeFile, mkdir, readFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+/**
+ * 飞书媒体文件下载器
+ *
+ * 负责将飞书消息中的图片/文件/音频/视频下载到本地磁盘。
+ * 下载失败时返回 null，不阻断消息处理。
+ */
+export class MediaDownloader {
+    client;
+    mediaDir;
+    constructor(client, config) {
+        this.client = client;
+        this.mediaDir = config.mediaDir;
+    }
+    /** 确保媒体目录存在 */
+    async ensureDir() {
+        await mkdir(this.mediaDir, { recursive: true });
+    }
+    /**
+     * 下载飞书媒体文件到本地
+     *
+     * @param messageId 飞书消息 ID（图片下载需要）
+     * @param msgType 消息类型：image | file | audio | video
+     * @param contentJson 解析后的消息内容 JSON
+     * @returns MediaAttachment 或 null（下载失败时）
+     */
+    async download(messageId, msgType, contentJson) {
+        try {
+            let data = null;
+            let filename = null;
+            let sourceKey = '';
+            if (msgType === 'image') {
+                const result = await this.downloadImage(messageId, contentJson);
+                if (!result)
+                    return null;
+                ({ data, filename, sourceKey } = result);
+            }
+            else if (msgType === 'file' || msgType === 'audio' || msgType === 'video') {
+                const result = await this.downloadFile(messageId, msgType, contentJson);
+                if (!result)
+                    return null;
+                ({ data, filename, sourceKey } = result);
+            }
+            else {
+                return null;
+            }
+            if (!data || !filename)
+                return null;
+            const safeFilename = `${messageId}_${filename}`.replace(/[/\\:*?"<>|]/g, '_');
+            const localPath = join(this.mediaDir, safeFilename);
+            const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+            await writeFile(localPath, buffer);
+            return {
+                localPath,
+                mediaType: msgType,
+                originalName: filename,
+                sourceKey,
+                size: buffer.length,
+            };
+        }
+        catch (err) {
+            console.error(`[media-downloader] 下载 ${msgType} 失败:`, err);
+            return null;
+        }
+    }
+    /**
+     * 从飞书 SDK 文件下载响应中提取 Buffer
+     *
+     * 飞书 SDK 返回 { writeFile, getReadableStream, headers }，不是直接的 Buffer。
+     * 优先用 getReadableStream 流式读取，fallback 到 writeFile 临时文件。
+     */
+    async extractBuffer(resp) {
+        const r = resp;
+        // 方式 1：通过 getReadableStream 流式读取（首选，不需要临时文件）
+        if (typeof r.getReadableStream === 'function') {
+            try {
+                const stream = r.getReadableStream();
+                const chunks = [];
+                for await (const chunk of stream) {
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                }
+                if (chunks.length > 0)
+                    return Buffer.concat(chunks);
+            }
+            catch {
+                // stream 读取失败，fallthrough 到 writeFile
+            }
+        }
+        // 方式 2：通过 writeFile 写入临时文件再读取
+        if (typeof r.writeFile === 'function') {
+            const tmpPath = join(tmpdir(), `anya-media-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+            try {
+                await r.writeFile(tmpPath);
+                const data = await readFile(tmpPath);
+                await unlink(tmpPath).catch(() => { });
+                if (data.length > 0)
+                    return data;
+            }
+            catch {
+                await unlink(tmpPath).catch(() => { });
+            }
+        }
+        // 方式 3：兼容旧版本 SDK 可能直接返回 Buffer 的情况
+        if (Buffer.isBuffer(r))
+            return r;
+        if (r instanceof Uint8Array)
+            return Buffer.from(r);
+        const rawData = r.data;
+        if (Buffer.isBuffer(rawData))
+            return rawData;
+        if (rawData instanceof Uint8Array)
+            return Buffer.from(rawData);
+        return null;
+    }
+    async downloadImage(messageId, contentJson) {
+        const imageKey = contentJson.image_key;
+        if (!imageKey || !messageId)
+            return null;
+        const resp = await this.client.im.messageResource.get({
+            path: { message_id: messageId, file_key: imageKey },
+            params: { type: 'image' },
+        });
+        const data = await this.extractBuffer(resp);
+        if (!data)
+            return null;
+        const filename = resp?.fileName ?? `${imageKey.slice(0, 16)}.jpg`;
+        return { data, filename, sourceKey: imageKey };
+    }
+    async downloadFile(messageId, msgType, contentJson) {
+        const fileKey = contentJson.file_key;
+        if (!fileKey || !messageId)
+            return null;
+        const resp = await this.client.im.messageResource.get({
+            path: { message_id: messageId, file_key: fileKey },
+            params: { type: msgType === 'file' ? 'file' : msgType },
+        });
+        const data = await this.extractBuffer(resp);
+        if (!data)
+            return null;
+        const ext = msgType === 'audio' ? '.opus' : (msgType === 'video' ? '.mp4' : '');
+        const filename = resp?.fileName
+            ?? contentJson.file_name
+            ?? `${fileKey.slice(0, 16)}${ext}`;
+        return { data, filename, sourceKey: fileKey };
+    }
+}
+//# sourceMappingURL=media-downloader.js.map

package/apps/server/dist/gateway/message-events.js

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'node:events';
+/**
+ * 全局消息事件总线
+ *
+ * message-intake 和 feishu-sender 写入 message_log 后 emit 'message' 事件，
+ * http.ts 的 SSE 端点监听该事件推送给客户端。
+ */
+export const messageEvents = new EventEmitter();
+messageEvents.setMaxListeners(100);
+//# sourceMappingURL=message-events.js.map

package/apps/server/dist/gateway/message-intake.js

@@ -0,0 +1,50 @@
+import { insertMessageLog } from '@team-anya/db';
+export class MessageIntake {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * 处理新消息：最小检测 + 透传给 Loid
+     */
+    async handle(message) {
+        const logger = this.deps.logger;
+        // 1. 记录到 DB（审计用）
+        try {
+            const metadataObj = {
+                ...message.metadata,
+                ...(message.media.length > 0 ? { media: message.media } : {}),
+                ...(message.sender ? { sender_open_id: message.sender } : {}),
+            };
+            insertMessageLog(this.deps.db, {
+                chat_id: message.chatId ?? null,
+                sender: message.senderName ?? message.sender ?? null,
+                content: message.content,
+                direction: 'inbound',
+                source_type: message.metadata?.source_type ?? 'unknown',
+                source_ref: message.metadata?.message_id,
+                trace_id: message.metadata?._traceId,
+                metadata: Object.keys(metadataObj).length > 0
+                    ? JSON.stringify(metadataObj)
+                    : null,
+            });
+        }
+        catch (err) {
+            logger?.error('[MessageIntake] 记录消息失败:', err);
+        }
+        // 1.5 命令拦截（在构建上下文之前）
+        if (this.deps.commandRouter) {
+            const handled = await this.deps.commandRouter.tryHandle(message);
+            if (handled) {
+                logger?.info(`[MessageIntake] 命令已拦截处理，跳过 Loid`);
+                return;
+            }
+        }
+        // 2. 构建上下文（含产品/项目注册表）
+        const context = await this.deps.contextBuilder.buildMessageContext(message);
+        // 3. 透传给 Loid（完全自主判断）
+        logger?.info(`[MessageIntake] 转发消息给 Loid: ${message.sender}@${message.chatId ?? 'DM'}`);
+        await this.deps.loidBrain.handleNewMessage(context);
+    }
+}
+//# sourceMappingURL=message-intake.js.map

package/apps/server/dist/gateway/message-queue.js

@@ -0,0 +1,104 @@
+import { randomUUID } from 'node:crypto';
+// ── EventDedup ──
+class EventDedup {
+    ttlMs;
+    seen = new Map();
+    timer;
+    constructor(ttlMs) {
+        this.ttlMs = ttlMs;
+        this.timer = setInterval(() => this.cleanup(), ttlMs);
+    }
+    isDuplicate(eventId) {
+        if (this.seen.has(eventId)) {
+            return true;
+        }
+        this.seen.set(eventId, Date.now());
+        return false;
+    }
+    get size() {
+        return this.seen.size;
+    }
+    dispose() {
+        clearInterval(this.timer);
+        this.seen.clear();
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [id, ts] of this.seen) {
+            if (now - ts > this.ttlMs) {
+                this.seen.delete(id);
+            }
+        }
+    }
+}
+export class MessageQueue {
+    handler;
+    dedup;
+    sources = new Map();
+    logger;
+    constructor(config) {
+        this.handler = config.handler;
+        this.dedup = new EventDedup(config.dedupTtlMs ?? 5 * 60 * 1000);
+        this.logger = config.logger ?? { info: console.log, error: console.error };
+    }
+    enqueue(msg) {
+        const eventId = msg.metadata?.event_id;
+        if (eventId && this.dedup.isDuplicate(eventId)) {
+            // 重复事件，静默跳过
+            return;
+        }
+        const key = this.deriveSourceKey(msg);
+        let sq = this.sources.get(key);
+        if (!sq) {
+            sq = { pending: [], processing: false };
+            this.sources.set(key, sq);
+        }
+        sq.pending.push(msg);
+        if (!sq.processing) {
+            this.processQueue(key, sq);
+        }
+    }
+    getQueueStats() {
+        let totalPending = 0;
+        for (const sq of this.sources.values()) {
+            totalPending += sq.pending.length;
+        }
+        return {
+            sourceCount: this.sources.size,
+            totalPending,
+            dedupCacheSize: this.dedup.size,
+        };
+    }
+    dispose() {
+        this.dedup.dispose();
+    }
+    deriveSourceKey(msg) {
+        if (msg.chatId && !msg.isDirectMessage) {
+            return msg.chatId;
+        }
+        if (msg.sender) {
+            return msg.sender;
+        }
+        return 'default';
+    }
+    async processQueue(key, sq) {
+        sq.processing = true;
+        while (sq.pending.length > 0) {
+            const current = sq.pending.shift();
+            // 为每条消息注入 traceId
+            if (!current.metadata)
+                current.metadata = {};
+            if (!current.metadata._traceId) {
+                current.metadata._traceId = randomUUID();
+            }
+            try {
+                await this.handler(current);
+            }
+            catch (err) {
+                this.logger.error('[MessageQueue] handler 异常:', err);
+            }
+        }
+        sq.processing = false;
+    }
+}
+//# sourceMappingURL=message-queue.js.map

package/apps/server/dist/gateway/session-reader.js

@@ -0,0 +1,142 @@
+/**
+ * CC Session JSONL 文件读取器
+ *
+ * 从 ~/.claude/projects/{encoded-path}/{sessionId}.jsonl 读取会话数据。
+ * 参考 reference-projects/claude-run/api/storage.ts 适配。
+ */
+import { readFileSync, existsSync, readdirSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+// ── 核心函数 ──
+/**
+ * 编码项目路径为 Claude 的目录名
+ * 与 Claude Code 内部逻辑一致：将路径分隔符替换为 `-`
+ */
+function encodeProjectPath(projectPath) {
+    // Claude Code 使用 encodeURIComponent 风格但实际更简单：
+    // 去掉开头 /，把 / 替换为 -
+    return projectPath.replace(/^\//, '').replace(/\//g, '-');
+}
+/**
+ * 获取 Claude 数据目录
+ */
+function getClaudeDir() {
+    return join(homedir(), '.claude');
+}
+/**
+ * 查找 session JSONL 文件
+ */
+export function findSessionFile(sessionId, projectPath) {
+    const claudeDir = getClaudeDir();
+    const projectsDir = join(claudeDir, 'projects');
+    if (!existsSync(projectsDir))
+        return null;
+    // 如果指定了项目路径，直接在对应目录查找
+    if (projectPath) {
+        const encoded = encodeProjectPath(projectPath);
+        const filePath = join(projectsDir, encoded, `${sessionId}.jsonl`);
+        if (existsSync(filePath))
+            return filePath;
+    }
+    // 遍历所有项目目录查找
+    try {
+        const dirs = readdirSync(projectsDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            const filePath = join(projectsDir, dir.name, `${sessionId}.jsonl`);
+            if (existsSync(filePath))
+                return filePath;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+/**
+ * 读取 session JSONL 文件并解析为消息数组
+ */
+export function readSessionConversation(sessionId, projectPath) {
+    const filePath = findSessionFile(sessionId, projectPath);
+    if (!filePath)
+        return [];
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n').filter(line => line.trim());
+        const messages = [];
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                // JSONL 条目可能是完整消息或包装在 message 字段中
+                if (entry.type === 'user' || entry.type === 'assistant') {
+                    messages.push(entry);
+                }
+                else if (entry.type === 'summary') {
+                    messages.push(entry);
+                }
+            }
+            catch {
+                // 跳过无法解析的行
+            }
+        }
+        return messages;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 从指定 byte offset 开始增量读取 JSONL 文件
+ * 参考 claude-run/api/storage.ts getConversationStream
+ */
+export function readSessionStream(sessionId, fromOffset = 0, projectPath) {
+    const filePath = findSessionFile(sessionId, projectPath);
+    if (!filePath)
+        return { messages: [], nextOffset: 0 };
+    try {
+        const fileStat = statSync(filePath);
+        const fileSize = fileStat.size;
+        if (fromOffset >= fileSize) {
+            return { messages: [], nextOffset: fromOffset };
+        }
+        const bufSize = fileSize - fromOffset;
+        const buf = Buffer.alloc(bufSize);
+        const fd = openSync(filePath, 'r');
+        try {
+            readSync(fd, buf, 0, bufSize, fromOffset);
+        }
+        finally {
+            closeSync(fd);
+        }
+        const chunk = buf.toString('utf-8');
+        const lines = chunk.split('\n');
+        const messages = [];
+        let bytesConsumed = 0;
+        for (const line of lines) {
+            const lineBytes = Buffer.byteLength(line, 'utf-8') + 1; // +1 for \n
+            if (line.trim()) {
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.type === 'user' || entry.type === 'assistant' || entry.type === 'summary') {
+                        messages.push(entry);
+                    }
+                    bytesConsumed += lineBytes;
+                }
+                catch {
+                    // 不完整的行（文件还在写入），停止读取
+                    break;
+                }
+            }
+            else {
+                bytesConsumed += lineBytes;
+            }
+        }
+        const nextOffset = fromOffset + bytesConsumed;
+        return { messages, nextOffset: nextOffset > fileSize ? fileSize : nextOffset };
+    }
+    catch {
+        return { messages: [], nextOffset: fromOffset };
+    }
+}
+//# sourceMappingURL=session-reader.js.map

package/apps/server/dist/gateway/ws-push.js

@@ -0,0 +1,115 @@
+import { WebSocketServer } from 'ws';
+export class WsPushServer {
+    wss = null;
+    config;
+    logger;
+    heartbeatTimer = null;
+    clients = new Map();
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger ?? { info: console.log, error: console.error, warn: console.warn };
+    }
+    /**
+     * 启动 WebSocket Server
+     */
+    start() {
+        return new Promise((resolve, reject) => {
+            this.wss = new WebSocketServer({ port: this.config.port });
+            this.wss.on('listening', () => {
+                this.logger.info(`WsPushServer 已启动，监听端口 ${this.config.port}`);
+                this.startHeartbeat();
+                resolve();
+            });
+            this.wss.on('error', (err) => {
+                this.logger.error('WsPushServer 错误:', err);
+                reject(err);
+            });
+            this.wss.on('connection', (ws) => {
+                this.onConnection(ws);
+            });
+        });
+    }
+    /**
+     * 关闭 WebSocket Server
+     */
+    async stop() {
+        this.stopHeartbeat();
+        if (!this.wss)
+            return;
+        // 关闭所有客户端连接
+        for (const [ws] of this.clients) {
+            ws.terminate();
+        }
+        this.clients.clear();
+        return new Promise((resolve) => {
+            this.wss.close(() => {
+                this.wss = null;
+                this.logger.info('WsPushServer 已关闭');
+                resolve();
+            });
+        });
+    }
+    /**
+     * 广播事件给所有连接的客户端
+     */
+    broadcast(event) {
+        const message = JSON.stringify(event);
+        for (const [ws] of this.clients) {
+            if (ws.readyState === 1 /* WebSocket.OPEN */) {
+                ws.send(message, (err) => {
+                    if (err) {
+                        this.logger.error('广播消息失败:', err);
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * 获取当前连接的客户端数量
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+    onConnection(ws) {
+        const meta = { isAlive: true };
+        this.clients.set(ws, meta);
+        ws.on('pong', () => {
+            meta.isAlive = true;
+        });
+        ws.on('close', () => {
+            this.clients.delete(ws);
+        });
+        ws.on('error', (err) => {
+            this.logger.error('WsPush 客户端错误:', err);
+            this.clients.delete(ws);
+        });
+    }
+    /**
+     * 启动心跳检测
+     */
+    startHeartbeat() {
+        const intervalMs = this.config.heartbeatIntervalMs ?? 30_000;
+        this.heartbeatTimer = setInterval(() => {
+            for (const [ws, meta] of this.clients) {
+                if (!meta.isAlive) {
+                    this.logger.warn('心跳超时，断开客户端');
+                    ws.terminate();
+                    this.clients.delete(ws);
+                    continue;
+                }
+                meta.isAlive = false;
+                ws.ping();
+            }
+        }, intervalMs);
+    }
+    /**
+     * 停止心跳检测
+     */
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=ws-push.js.map

package/apps/server/dist/loid/brain.js

@@ -0,0 +1,104 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { startLoidMcpServer } from './mcp-server.js';
+import { LoidSessionManager } from './session-manager.js';
+// ── LoidBrain ──
+export class LoidBrain {
+    config;
+    deps;
+    ready = false;
+    mcpUrl = null;
+    mcpClose;
+    protocols = {};
+    sessionManager = null;
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+    }
+    async init() {
+        // 1. 启动指挥型 MCP server
+        const mcp = await startLoidMcpServer(this.deps.mcpDeps);
+        this.mcpClose = mcp.close;
+        this.mcpUrl = mcp.url;
+        // 2. 预读协议文件到内存
+        this.loadProtocols();
+        // 3. 验证 workingDir 存在
+        if (!existsSync(this.config.loidWorkDir)) {
+            this.config.logger?.error(`loidWorkDir 不存在: ${this.config.loidWorkDir}`);
+        }
+        // 4. 初始化 SessionManager
+        const logDir = join(this.config.loidWorkDir, '..', '..', 'data', 'logs', 'cc-logs');
+        this.sessionManager = new LoidSessionManager({
+            broker: this.deps.broker,
+            backendConfig: {
+                type: 'claude-code',
+                binary: this.config.binary,
+                workingDir: this.config.loidWorkDir,
+                dangerouslySkipPermissions: true,
+                maxTurns: this.config.maxTurnsPerSession ?? 50,
+                mcpServers: [{ name: 'loid-tools', url: this.mcpUrl }],
+            },
+            idleTimeoutMs: this.config.idleTimeoutMs,
+            maxTurnsPerSession: this.config.maxTurnsPerSession,
+            protocols: this.protocols,
+            logDir,
+            logger: this.config.logger,
+        }, {
+            db: this.deps.mcpDeps.db,
+        });
+        this.ready = true;
+        this.config.logger?.info('LoidBrain 已初始化 (Session 模式)');
+    }
+    /**
+     * 仅释放所有 Loid 会话（重启场景用），保留 MCP server 和 ready 状态
+     */
+    async disposeSessions() {
+        await this.sessionManager?.dispose();
+        this.config.logger?.info('LoidBrain 会话已全部释放（MCP server 保留）');
+    }
+    async dispose() {
+        await this.sessionManager?.dispose();
+        await this.mcpClose?.();
+        this.ready = false;
+        this.config.logger?.info('LoidBrain 已关闭');
+    }
+    /**
+     * 入口 1: 处理新消息
+     * 委托给 SessionManager 管理长驻会话
+     */
+    async handleNewMessage(ctx) {
+        this.ensureReady();
+        const chatId = ctx.message.chatId ?? ctx.message.sender ?? 'default';
+        const sender = ctx.message.sender ?? '未知';
+        this.config.logger?.info(`[anya:pipeline] [Loid] 收到消息 ${sender}@${chatId}: "${ctx.message.content.slice(0, 60)}"`);
+        await this.sessionManager.handleMessage(chatId, ctx);
+    }
+    /**
+     * 入口 2: 处理 Yor 交付
+     * 委托给 SessionManager 管理验收会话
+     */
+    async handleDelivery(ctx) {
+        this.ensureReady();
+        this.config.logger?.info(`[anya:pipeline] [Loid] 开始验收 ${ctx.taskId} (exit=${ctx.exitCode})`);
+        await this.sessionManager.handleDelivery(ctx);
+    }
+    // ── 私有方法 ──
+    ensureReady() {
+        if (!this.ready) {
+            throw new Error('LoidBrain 尚未初始化，请先调用 init()');
+        }
+    }
+    loadProtocols() {
+        const protocolNames = ['review', 'report'];
+        for (const name of protocolNames) {
+            const filePath = join(this.config.protocolsDir, `${name}.md`);
+            if (existsSync(filePath)) {
+                this.protocols[name] = readFileSync(filePath, 'utf-8');
+            }
+            else {
+                this.config.logger?.error?.(`协议文件不存在: ${filePath}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=brain.js.map