devchain-cli 0.12.3 → 0.13.0

package/dist/server/modules/mcp/services/handlers/chat-tools.js

@@ -7,142 +7,58 @@ exports.handleChatReadHistory = handleChatReadHistory;
 const common_1 = require("@nestjs/common");
 const logger_1 = require("../../../../common/logging/logger");
 const error_types_1 = require("../../../../common/errors/error-types");
-const confirmed_delivery_helper_1 = require("../../../terminal/services/confirmed-delivery.helper");
-const mcp_dto_1 = require("../../dtos/mcp.dto");
+const service_unavailable_error_1 = require("../../../../common/errors/service-unavailable.error");
+const session_context_helpers_1 = require("../utils/session-context-helpers");
+const redact_1 = require("../utils/redact");
+const recipient_resolution_1 = require("./chat-tools/recipient-resolution");
 const logger = (0, logger_1.createLogger)('McpService');
-function getActorFromContext(ctx) {
-    if (ctx.type === 'agent') {
-        return ctx.agent;
-    }
-    if (ctx.type === 'guest') {
-        return {
-            id: ctx.guest.id,
-            name: ctx.guest.name,
-            projectId: ctx.guest.projectId,
-        };
-    }
-    return null;
-}
-function redactSessionId(sessionId) {
-    if (!sessionId)
-        return '(none)';
-    return sessionId.slice(0, 4) + '****';
-}
-function redactParams(params) {
-    if (!params || typeof params !== 'object')
-        return params;
-    const obj = params;
-    if ('sessionId' in obj && typeof obj.sessionId === 'string') {
-        return { ...obj, sessionId: redactSessionId(obj.sessionId) };
-    }
-    return params;
-}
-function missingSessionResolver() {
-    return {
-        success: false,
-        error: {
-            code: 'SERVICE_UNAVAILABLE',
-            message: 'Session resolution requires full app context (not available in standalone MCP mode)',
-        },
-    };
-}
-async function resolveSessionContext(ctx, sessionId) {
-    if (!ctx.resolveSessionContext) {
-        return missingSessionResolver();
-    }
-    return ctx.resolveSessionContext(sessionId);
-}
-async function resolveRecipientByName(ctx, projectId, name) {
-    try {
-        const agent = await ctx.storage.getAgentByName(projectId, name);
-        return {
-            type: 'agent',
-            id: agent.id,
-            name: agent.name,
-        };
-    }
-    catch (error) {
-        if (!(error instanceof error_types_1.NotFoundError)) {
-            throw error;
-        }
-    }
-    const guest = await ctx.storage.getGuestByName(projectId, name);
-    if (guest) {
-        return {
-            type: 'guest',
-            id: guest.id,
-            name: guest.name,
-            tmuxSessionId: guest.tmuxSessionId,
-        };
-    }
-    return null;
-}
-async function getAvailableRecipientNames(ctx, projectId) {
-    const [agentsResult, guests] = await Promise.all([
-        ctx.storage.listAgents(projectId, { limit: 100, offset: 0 }),
-        ctx.storage.listGuests(projectId),
-    ]);
-    const agentNames = agentsResult.items.map((a) => a.name);
-    const guestNames = guests.map((g) => `${g.name} (guest)`);
-    return [...agentNames, ...guestNames];
-}
 async function handleSendMessage(ctx, params) {
-    if (!ctx.sessionsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'Chat functionality requires full app context (not available in standalone MCP mode)',
-            },
-        };
-    }
-    const validated = mcp_dto_1.SendMessageParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const sessionCtx = sessionCtxResult.data;
-    const sender = getActorFromContext(sessionCtx);
-    const project = sessionCtx.project;
-    if (!sender) {
-        return {
-            success: false,
-            error: {
-                code: 'AGENT_REQUIRED',
-                message: 'Session must be associated with an agent or guest to send messages',
-            },
-        };
-    }
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
-            },
-        };
-    }
-    if (sessionCtx.type === 'guest') {
-        if (validated.threadId) {
+    const validated = params;
+    try {
+        const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+        if (!sessionCtxResult.success)
+            return sessionCtxResult;
+        const sessionCtx = sessionCtxResult.data;
+        const sender = (0, session_context_helpers_1.getActorFromContext)(sessionCtx);
+        const project = sessionCtx.project;
+        if (!sender) {
             return {
                 success: false,
                 error: {
-                    code: 'GUEST_THREAD_NOT_ALLOWED',
-                    message: 'Guests cannot use threaded messaging. Use recipientAgentNames for direct messaging.',
+                    code: 'AGENT_REQUIRED',
+                    message: 'Session must be associated with an agent or guest to send messages',
                 },
             };
         }
-        if (validated.recipient === 'user' && !validated.teamName) {
+        if (!project) {
             return {
                 success: false,
                 error: {
-                    code: 'GUEST_USER_DM_NOT_ALLOWED',
-                    message: 'Guests cannot send direct messages to users.',
+                    code: 'PROJECT_NOT_FOUND',
+                    message: 'No project associated with this session',
                 },
             };
         }
-    }
-    try {
-        const autoLaunchSessions = process.env.NODE_ENV !== 'test';
+        if (sessionCtx.type === 'guest') {
+            if (validated.threadId) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'GUEST_THREAD_NOT_ALLOWED',
+                        message: 'Guests cannot use threaded messaging. Use recipientAgentNames for direct messaging.',
+                    },
+                };
+            }
+            if (validated.recipient === 'user' && !validated.teamName) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'GUEST_USER_DM_NOT_ALLOWED',
+                        message: 'Guests cannot send direct messages to users.',
+                    },
+                };
+            }
+        }
         const senderId = sender.id;
         const senderName = sender.name;
         const senderType = sessionCtx.type;
@@ -152,7 +68,7 @@ async function handleSendMessage(ctx, params) {
             !validated.threadId &&
             validated.recipient !== 'user') {
             const senderAgentId = sessionCtx.type === 'agent' ? sessionCtx.agent?.id : undefined;
-            if (!senderAgentId || !ctx.teamsService) {
+            if (!senderAgentId) {
                 return {
                     success: false,
                     error: {
@@ -187,15 +103,6 @@ async function handleSendMessage(ctx, params) {
         let teamDelivery;
         let teamDeliveryMode;
         if (effectiveTeamName) {
-            if (!ctx.teamsService) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'SERVICE_UNAVAILABLE',
-                        message: 'Team routing requires full app context (not available in standalone MCP mode)',
-                    },
-                };
-            }
             const matchedTeam = await ctx.teamsService.findTeamByExactName(project.id, effectiveTeamName);
             if (!matchedTeam) {
                 return {
@@ -243,9 +150,9 @@ async function handleSendMessage(ctx, params) {
         }
         else if (validated.recipientAgentNames && validated.recipientAgentNames.length > 0) {
             for (const name of validated.recipientAgentNames) {
-                const recipient = await resolveRecipientByName(ctx, project.id, name);
+                const recipient = await (0, recipient_resolution_1.resolveRecipientByName)(ctx, project.id, name);
                 if (!recipient) {
-                    const availableNames = await getAvailableRecipientNames(ctx, project.id);
+                    const availableNames = await (0, recipient_resolution_1.getAvailableRecipientNames)(ctx, project.id);
                     return {
                         success: false,
                         error: {
@@ -281,15 +188,6 @@ async function handleSendMessage(ctx, params) {
             };
         }
         if (!validated.threadId && senderId && recipientType !== 'user') {
-            if (!ctx.messagePoolService || !ctx.settingsService) {
-                return {
-                    success: false,
-                    error: {
-                        code: 'SERVICE_UNAVAILABLE',
-                        message: 'Message pool functionality requires full app context (not available in standalone MCP mode)',
-                    },
-                };
-            }
             if (uniqueRecipients.length === 0) {
                 return {
                     success: false,
@@ -300,104 +198,78 @@ async function handleSendMessage(ctx, params) {
                 };
             }
             const queued = [];
-            const poolConfig = ctx.settingsService.getMessagePoolConfigForProject(project.id);
-            const activeSessions = ctx.sessionsService
-                ? await ctx.sessionsService.listActiveSessions()
-                : [];
-            for (const recipient of uniqueRecipients) {
-                const injectionText = `\n[This message is sent from "${senderName}" ${senderType} use devchain_send_message tool for communication]\n${validated.message}\n`;
-                if (recipient.type === 'agent') {
-                    let session = activeSessions.find((s) => s.agentId === recipient.id);
-                    let wasLaunched = false;
-                    if (!session && autoLaunchSessions && ctx.sessionsService) {
-                        try {
-                            const launched = await ctx.sessionsService.launchSession({
-                                projectId: project.id,
-                                agentId: recipient.id,
-                                options: { silent: true },
-                            });
-                            session = launched;
-                            activeSessions.push(launched);
-                            wasLaunched = true;
-                        }
-                        catch {
-                        }
-                    }
-                    await ctx.messagePoolService.enqueue(recipient.id, injectionText, {
+            const agentRecipients = uniqueRecipients.filter((r) => r.type === 'agent');
+            const guestRecipients = uniqueRecipients.filter((r) => r.type === 'guest');
+            if (agentRecipients.length > 0) {
+                const outcome = await ctx.agentMessageDelivery.deliver(agentRecipients.map((r) => r.id), {
+                    kind: 'mcp.direct',
+                    body: validated.message,
+                    source: 'mcp.send_message',
+                    projectId: project.id,
+                    senderName,
+                    senderType: senderType,
+                    senderAgentId: senderId,
+                }, { submitKeys: ['Enter'] });
+                for (const result of outcome.results) {
+                    const recipient = agentRecipients.find((r) => r.id === result.agentId);
+                    queued.push({
+                        name: recipient?.name ?? result.agentId,
+                        type: 'agent',
+                        status: result.status === 'failed' ? 'failed' : 'queued',
+                        error: result.error,
+                    });
+                }
+            }
+            for (const recipient of guestRecipients) {
+                if (!recipient.tmuxSessionId) {
+                    queued.push({
+                        name: recipient.name,
+                        type: 'guest',
+                        status: 'failed',
+                        error: 'No session',
+                    });
+                    continue;
+                }
+                try {
+                    const guestText = ctx.agentMessageDelivery.formatMessage({
+                        kind: 'mcp.direct',
+                        body: validated.message,
                         source: 'mcp.send_message',
-                        submitKeys: ['Enter'],
-                        senderAgentId: senderId,
                         projectId: project.id,
-                        agentName: recipient.name,
+                        senderName,
+                        senderType: senderType,
                     });
+                    const result = await ctx.agentMessageDelivery.deliverToGuest(recipient.tmuxSessionId, guestText, ['Enter']);
                     queued.push({
                         name: recipient.name,
-                        type: 'agent',
-                        status: wasLaunched ? 'launched' : 'queued',
+                        type: 'guest',
+                        status: result.delivered ? 'delivered' : 'failed',
+                        error: result.error,
                     });
                 }
-                else {
-                    const isOnline = ctx.tmuxService
-                        ? await ctx.tmuxService.hasSession(recipient.tmuxSessionId)
-                        : false;
-                    if (!isOnline) {
-                        queued.push({
-                            name: recipient.name,
-                            type: 'guest',
-                            status: 'failed',
-                            error: 'Recipient offline',
-                        });
-                    }
-                    else if (ctx.tmuxService) {
-                        try {
-                            const delivery = await (0, confirmed_delivery_helper_1.deliverWithConfirmation)(ctx.tmuxService, null, {
-                                tmuxSessionId: recipient.tmuxSessionId,
-                                text: injectionText,
-                            });
-                            queued.push({
-                                name: recipient.name,
-                                type: 'guest',
-                                status: delivery.confirmed ? 'delivered' : 'unconfirmed',
-                            });
-                        }
-                        catch (error) {
-                            logger.warn({ guestId: recipient.id, tmuxSessionId: recipient.tmuxSessionId, error }, 'Failed to deliver message to guest');
-                            queued.push({
-                                name: recipient.name,
-                                type: 'guest',
-                                status: 'failed',
-                                error: error instanceof Error ? error.message : 'Delivery failed',
-                            });
-                        }
-                    }
-                    else {
+                catch (error) {
+                    if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
                         queued.push({
                             name: recipient.name,
                             type: 'guest',
                             status: 'failed',
-                            error: 'Tmux service unavailable',
+                            error: 'Delivery service unavailable',
                         });
+                        continue;
                     }
+                    throw error;
                 }
             }
+            const estimatedDeliveryMs = ctx.settingsService.getMessagePoolConfigForProject(project.id).delayMs;
             const response = {
                 mode: 'pooled',
                 queuedCount: queued.length,
                 queued,
-                estimatedDeliveryMs: poolConfig.delayMs,
+                estimatedDeliveryMs,
                 ...(teamDelivery ? { teamDelivery } : {}),
             };
             return { success: true, data: response };
         }
-        if (!ctx.chatService) {
-            return {
-                success: false,
-                error: {
-                    code: 'SERVICE_UNAVAILABLE',
-                    message: 'Chat functionality requires full app context (not available in standalone MCP mode)',
-                },
-            };
-        }
         let threadId = validated.threadId;
         if (!threadId && senderId) {
             if (recipientType === 'user') {
@@ -427,36 +299,30 @@ async function handleSendMessage(ctx, params) {
         if (senderId && thread.members && thread.members.length > 1 && targetAgentIds.length === 0) {
             targetAgentIds = thread.members.filter((id) => id !== senderId);
         }
-        const activeSessions = await ctx.sessionsService.listActiveSessions();
         const delivered = [];
-        for (const agentId of targetAgentIds) {
-            const agent = await ctx.storage.getAgent(agentId);
-            let session = activeSessions.find((s) => s.agentId === agentId);
-            if (!session && autoLaunchSessions) {
-                try {
-                    const launched = await ctx.sessionsService.launchSession({
-                        projectId: project.id,
-                        agentId,
-                        options: { silent: true },
-                    });
-                    session = launched;
-                    activeSessions.push(launched);
-                }
-                catch {
-                }
-            }
-            if (!session) {
-                delivered.push({ agentId, agentName: agent.name, sessionId: '', status: 'queued' });
-                continue;
+        if (targetAgentIds.length > 0) {
+            const outcome = await ctx.agentMessageDelivery.deliver(targetAgentIds, {
+                kind: 'mcp.thread',
+                body: validated.message,
+                source: 'mcp.chat_thread',
+                projectId: project.id,
+                senderName,
+                senderType: 'agent',
+                threadId,
+                messageId: message.id,
+                senderAgentId: senderId,
+            }, { submitKeys: ['Enter'], immediate: true });
+            for (const result of outcome.results) {
+                const agent = await ctx.storage.getAgent(result.agentId);
+                delivered.push({
+                    agentId: result.agentId,
+                    agentName: agent.name,
+                    sessionId: '',
+                    status: result.status === 'failed'
+                        ? 'queued'
+                        : result.status,
+                });
             }
-            const injectionText = `\n[CHAT] From: ${senderName} • Thread: ${threadId}\n${validated.message}\n[ACK] tools/call { name: "devchain_chat_ack", arguments: { sessionId: "${session.id}", thread_id: "${threadId}", message_id: "${message.id}" } }\n`;
-            const injectResult = await ctx.sessionsService.injectTextIntoSession(session.id, injectionText);
-            delivered.push({
-                agentId,
-                agentName: agent.name,
-                sessionId: session.id,
-                status: injectResult.confirmed ? 'delivered' : 'unconfirmed',
-            });
         }
         const response = {
             mode: 'thread',
@@ -468,7 +334,10 @@ async function handleSendMessage(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
-        logger.error({ error, params: redactParams(validated) }, 'sendMessage failed');
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return { success: false, error: { code: 'SERVICE_UNAVAILABLE', message: error.message } };
+        }
+        logger.error({ error, params: (0, redact_1.redactParams)(params) }, 'sendMessage failed');
         return {
             success: false,
             error: {
@@ -479,33 +348,24 @@ async function handleSendMessage(ctx, params) {
     }
 }
 async function handleChatAck(ctx, params) {
-    if (!ctx.chatService || !ctx.terminalGateway) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'Chat acknowledgment requires full app context (not available in standalone MCP mode)',
-            },
-        };
-    }
-    const validated = mcp_dto_1.ChatAckParamsSchema.parse(params);
+    const validated = params;
     const { thread_id: threadId, message_id: messageId } = validated;
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const sessionCtx = sessionCtxResult.data;
-    const agent = getActorFromContext(sessionCtx);
-    if (!agent) {
-        return {
-            success: false,
-            error: {
-                code: 'AGENT_NOT_FOUND',
-                message: 'No agent associated with this session',
-            },
-        };
-    }
-    const agentId = agent.id;
     try {
+        const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+        if (!sessionCtxResult.success)
+            return sessionCtxResult;
+        const sessionCtx = sessionCtxResult.data;
+        const agent = (0, session_context_helpers_1.getActorFromContext)(sessionCtx);
+        if (!agent) {
+            return {
+                success: false,
+                error: {
+                    code: 'AGENT_NOT_FOUND',
+                    message: 'No agent associated with this session',
+                },
+            };
+        }
+        const agentId = agent.id;
         const thread = await ctx.chatService.getThread(threadId);
         const memberIds = thread.members ?? [];
         if (!memberIds.includes(agentId)) {
@@ -517,20 +377,12 @@ async function handleChatAck(ctx, params) {
                 },
             };
         }
-        const now = new Date().toISOString();
-        await ctx.storage.markMessageAsRead(messageId, agentId, now);
-        if (ctx.sessionsService) {
-            const activeSessions = await ctx.sessionsService.listActiveSessions();
-            const agentSession = activeSessions.find((s) => s.agentId === agentId);
-            if (agentSession && agentSession.tmuxSessionId) {
-                await ctx.chatService.acknowledgeInvite(threadId, messageId, agentId, agentSession.tmuxSessionId);
-            }
+        await ctx.chatService.markMessageAsRead(messageId, agentId);
+        const activeSessions = await ctx.sessionsService.listActiveSessions();
+        const agentSession = activeSessions.find((s) => s.agentId === agentId);
+        if (agentSession && agentSession.tmuxSessionId) {
+            await ctx.chatService.acknowledgeInvite(threadId, messageId, agentId, agentSession.tmuxSessionId);
         }
-        ctx.terminalGateway.broadcastEvent(`chat/${threadId}`, 'message.read', {
-            messageId,
-            agentId,
-            readAt: now,
-        });
         const response = {
             threadId,
             messageId,
@@ -541,7 +393,10 @@ async function handleChatAck(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
-        logger.error({ error, params: redactParams(validated) }, 'chatAck failed');
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return { success: false, error: { code: 'SERVICE_UNAVAILABLE', message: error.message } };
+        }
+        logger.error({ error, params: (0, redact_1.redactParams)(validated) }, 'chatAck failed');
         return {
             success: false,
             error: {
@@ -552,16 +407,7 @@ async function handleChatAck(ctx, params) {
     }
 }
 async function handleChatListMembers(ctx, params) {
-    if (!ctx.chatService || !ctx.sessionsService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'Chat members listing requires full app context (not available in standalone MCP mode)',
-            },
-        };
-    }
-    const validated = mcp_dto_1.ChatListMembersParamsSchema.parse(params);
+    const validated = params;
     try {
         const thread = await ctx.chatService.getThread(validated.thread_id);
         const memberIds = thread.members ?? [];
@@ -603,6 +449,9 @@ async function handleChatListMembers(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return { success: false, error: { code: 'SERVICE_UNAVAILABLE', message: error.message } };
+        }
         if (error instanceof common_1.NotFoundException || error instanceof error_types_1.NotFoundError) {
             return {
                 success: false,
@@ -623,16 +472,7 @@ async function handleChatListMembers(ctx, params) {
     }
 }
 async function handleChatReadHistory(ctx, params) {
-    if (!ctx.chatService) {
-        return {
-            success: false,
-            error: {
-                code: 'SERVICE_UNAVAILABLE',
-                message: 'Chat history requires full app context (not available in standalone MCP mode)',
-            },
-        };
-    }
-    const validated = mcp_dto_1.ChatReadHistoryParamsSchema.parse(params);
+    const validated = params;
     try {
         const thread = await ctx.chatService.getThread(validated.thread_id);
         const limit = validated.limit ?? 50;
@@ -701,6 +541,9 @@ async function handleChatReadHistory(ctx, params) {
         return { success: true, data: response };
     }
     catch (error) {
+        if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
+            return { success: false, error: { code: 'SERVICE_UNAVAILABLE', message: error.message } };
+        }
         if (error instanceof common_1.NotFoundException || error instanceof error_types_1.NotFoundError) {
             return {
                 success: false,