devchain-cli 0.5.0 → 0.6.0

package/dist/server/modules/mcp/services/mcp.service.js

@@ -19,8 +19,10 @@ const chat_service_1 = require("../../chat/services/chat.service");
 const sessions_service_1 = require("../../sessions/services/sessions.service");
 const sessions_message_pool_service_1 = require("../../sessions/services/sessions-message-pool.service");
 const terminal_gateway_1 = require("../../terminal/gateways/terminal.gateway");
+const tmux_service_1 = require("../../terminal/services/tmux.service");
 const epics_service_1 = require("../../epics/services/epics.service");
 const settings_service_1 = require("../../settings/services/settings.service");
+const guests_service_1 = require("../../guests/services/guests.service");
 const logger_1 = require("../../../common/logging/logger");
 const mcp_dto_1 = require("../dtos/mcp.dto");
 const instructions_resolver_1 = require("./instructions-resolver");
@@ -28,6 +30,19 @@ const error_types_1 = require("../../../common/errors/error-types");
 const common_2 = require("@nestjs/common");
 const zod_1 = require("zod");
 const logger = (0, logger_1.createLogger)('McpService');
+function getActorFromContext(ctx) {
+    if (ctx.type === 'agent') {
+        return ctx.agent;
+    }
+    else 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)';
@@ -43,14 +58,16 @@ function redactParams(params) {
     return params;
 }
 let McpService = class McpService {
-    constructor(storage, chatService, sessionsService, messagePoolService, terminalGateway, epicsService, settingsService) {
+    constructor(storage, chatService, sessionsService, messagePoolService, terminalGateway, tmuxService, epicsService, settingsService, guestsService) {
         this.storage = storage;
         this.chatService = chatService;
         this.sessionsService = sessionsService;
         this.messagePoolService = messagePoolService;
         this.terminalGateway = terminalGateway;
+        this.tmuxService = tmuxService;
         this.epicsService = epicsService;
         this.settingsService = settingsService;
+        this.guestsService = guestsService;
         this.DEFAULT_INLINE_MAX_BYTES = 64 * 1024;
         logger.info('McpService initialized');
         this.featureFlags = this.storage.getFeatureFlags();
@@ -145,6 +162,8 @@ let McpService = class McpService {
                     return await this.activityFinish(params);
                 case 'devchain_list_sessions':
                     return await this.listSessions();
+                case 'devchain_register_guest':
+                    return await this.registerGuest(params);
                 default:
                     logger.warn({ tool: normalizedTool }, 'Unknown MCP tool');
                     return {
@@ -525,21 +544,49 @@ let McpService = class McpService {
         const limit = validated.limit ?? 100;
         const offset = validated.offset ?? 0;
         const normalizedQuery = validated.q?.toLowerCase();
-        const fetchOptions = normalizedQuery ? { limit: limit + offset, offset: 0 } : { limit, offset };
-        const result = await this.storage.listAgents(project.id, fetchOptions);
-        let agents = result.items;
+        const MAX_COMBINED_FETCH = 1000;
+        const [agentsResult, guests] = await Promise.all([
+            this.storage.listAgents(project.id, { limit: MAX_COMBINED_FETCH, offset: 0 }),
+            this.storage.listGuests(project.id),
+        ]);
+        const [agentPresence, tmuxSessions] = await Promise.all([
+            this.sessionsService
+                ? this.sessionsService.getAgentPresence(project.id)
+                : Promise.resolve(new Map()),
+            this.tmuxService
+                ? this.tmuxService.listAllSessionNames()
+                : Promise.resolve(new Set()),
+        ]);
+        const agentItems = agentsResult.items.map((agent) => ({
+            id: agent.id,
+            name: agent.name,
+            profileId: agent.profileId,
+            description: agent.description,
+            type: 'agent',
+            online: agentPresence.get(agent.id)?.online ?? false,
+        }));
+        const guestItems = guests.map((guest) => ({
+            id: guest.id,
+            name: guest.name,
+            profileId: null,
+            description: guest.description,
+            type: 'guest',
+            online: tmuxSessions.has(guest.tmuxSessionId),
+        }));
+        let allItems = [...agentItems, ...guestItems].sort((a, b) => {
+            const nameCompare = a.name.localeCompare(b.name);
+            if (nameCompare !== 0)
+                return nameCompare;
+            return a.type === 'agent' ? -1 : 1;
+        });
         if (normalizedQuery) {
-            agents = agents.filter((agent) => agent.name.toLowerCase().includes(normalizedQuery));
+            allItems = allItems.filter((item) => item.name.toLowerCase().includes(normalizedQuery));
         }
-        const paginatedAgents = normalizedQuery ? agents.slice(offset, offset + limit) : agents;
+        const total = allItems.length;
+        const paginatedItems = allItems.slice(offset, offset + limit);
         const response = {
-            agents: paginatedAgents.map((agent) => ({
-                id: agent.id,
-                name: agent.name,
-                profileId: agent.profileId,
-                description: agent.description,
-            })),
-            total: normalizedQuery ? agents.length : result.total,
+            agents: paginatedItems,
+            total,
             limit,
             offset,
         };
@@ -1038,16 +1085,18 @@ let McpService = class McpService {
         const ctx = await this.resolveSessionContext(validated.sessionId);
         if (!ctx.success)
             return ctx;
-        const { agent: authorAgent, project } = ctx.data;
-        if (!authorAgent) {
+        const sessionCtx = ctx.data;
+        const authorActor = getActorFromContext(sessionCtx);
+        if (!authorActor) {
             return {
                 success: false,
                 error: {
                     code: 'AGENT_REQUIRED',
-                    message: 'Session must be associated with an agent to add comments',
+                    message: 'Session must be associated with an agent or guest to add comments',
                 },
             };
         }
+        const project = sessionCtx.project;
         if (!project) {
             return {
                 success: false,
@@ -1084,7 +1133,7 @@ let McpService = class McpService {
         }
         const comment = await this.storage.createEpicComment({
             epicId: validated.epicId,
-            authorName: authorAgent.name,
+            authorName: authorActor.name,
             content: validated.content,
         });
         const response = {
@@ -1307,6 +1356,40 @@ let McpService = class McpService {
         };
         return { success: true, data: response };
     }
+    async resolveRecipientByName(projectId, name) {
+        try {
+            const agent = await this.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 this.storage.getGuestByName(projectId, name);
+        if (guest) {
+            return {
+                type: 'guest',
+                id: guest.id,
+                name: guest.name,
+                tmuxSessionId: guest.tmuxSessionId,
+            };
+        }
+        return null;
+    }
+    async getAvailableRecipientNames(projectId) {
+        const [agentsResult, guests] = await Promise.all([
+            this.storage.listAgents(projectId, { limit: 100, offset: 0 }),
+            this.storage.listGuests(projectId),
+        ]);
+        const agentNames = agentsResult.items.map((a) => a.name);
+        const guestNames = guests.map((g) => `${g.name} (guest)`);
+        return [...agentNames, ...guestNames];
+    }
     async sendMessage(params) {
         if (!this.sessionsService) {
             return {
@@ -1321,13 +1404,15 @@ let McpService = class McpService {
         const ctx = await this.resolveSessionContext(validated.sessionId);
         if (!ctx.success)
             return ctx;
-        const { agent: senderAgent, project } = ctx.data;
-        if (!senderAgent) {
+        const sessionCtx = ctx.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 to send messages',
+                    message: 'Session must be associated with an agent or guest to send messages',
                 },
             };
         }
@@ -1340,20 +1425,53 @@ let McpService = class McpService {
                 },
             };
         }
+        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') {
+                return {
+                    success: false,
+                    error: {
+                        code: 'GUEST_USER_DM_NOT_ALLOWED',
+                        message: 'Guests cannot send direct messages to users.',
+                    },
+                };
+            }
+        }
         try {
             const autoLaunchSessions = process.env.NODE_ENV !== 'test';
-            const senderAgentId = senderAgent.id;
-            const senderAgentName = senderAgent.name;
+            const senderId = sender.id;
+            const senderName = sender.name;
+            const senderType = sessionCtx.type;
             const recipientType = validated.recipient ?? 'agents';
-            let normalizedRecipientIds = [];
+            const resolvedRecipients = [];
             if (validated.recipientAgentNames && validated.recipientAgentNames.length > 0) {
                 for (const name of validated.recipientAgentNames) {
-                    const agent = await this.storage.getAgentByName(project.id, name);
-                    normalizedRecipientIds.push(agent.id);
+                    const recipient = await this.resolveRecipientByName(project.id, name);
+                    if (!recipient) {
+                        const availableNames = await this.getAvailableRecipientNames(project.id);
+                        return {
+                            success: false,
+                            error: {
+                                code: 'RECIPIENT_NOT_FOUND',
+                                message: `Recipient "${name}" not found. Available: ${availableNames.join(', ') || 'none'}`,
+                            },
+                        };
+                    }
+                    if (recipient.id !== senderId) {
+                        resolvedRecipients.push(recipient);
+                    }
                 }
             }
-            normalizedRecipientIds = Array.from(new Set(normalizedRecipientIds.filter((id) => id && id !== senderAgentId)));
-            if (!validated.threadId && senderAgentId && recipientType !== 'user') {
+            const uniqueRecipients = resolvedRecipients.filter((r, i, arr) => arr.findIndex((x) => x.id === r.id) === i);
+            if (!validated.threadId && senderId && recipientType !== 'user') {
                 if (!this.messagePoolService || !this.settingsService) {
                     return {
                         success: false,
@@ -1363,12 +1481,12 @@ let McpService = class McpService {
                         },
                     };
                 }
-                if (normalizedRecipientIds.length === 0) {
+                if (uniqueRecipients.length === 0) {
                     return {
                         success: false,
                         error: {
                             code: 'RECIPIENTS_REQUIRED',
-                            message: 'Recipient agents must be provided when sending agent-to-agent without threadId.',
+                            message: 'Recipients must be provided when sending without threadId.',
                         },
                     };
                 }
@@ -1377,35 +1495,77 @@ let McpService = class McpService {
                 const activeSessions = this.sessionsService
                     ? await this.sessionsService.listActiveSessions()
                     : [];
-                for (const agentId of normalizedRecipientIds) {
-                    const agent = await this.storage.getAgent(agentId);
-                    let session = activeSessions.find((s) => s.agentId === agentId);
-                    let wasLaunched = false;
-                    if (!session && autoLaunchSessions && this.sessionsService) {
-                        try {
-                            const launched = await this.sessionsService.launchSession({
-                                projectId: project.id,
-                                agentId,
+                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 && this.sessionsService) {
+                            try {
+                                const launched = await this.sessionsService.launchSession({
+                                    projectId: project.id,
+                                    agentId: recipient.id,
+                                });
+                                session = launched;
+                                activeSessions.push(launched);
+                                wasLaunched = true;
+                            }
+                            catch {
+                            }
+                        }
+                        await this.messagePoolService.enqueue(recipient.id, injectionText, {
+                            source: 'mcp.send_message',
+                            submitKeys: ['Enter'],
+                            senderAgentId: senderId,
+                            projectId: project.id,
+                            agentName: recipient.name,
+                        });
+                        queued.push({
+                            name: recipient.name,
+                            type: 'agent',
+                            status: wasLaunched ? 'launched' : 'queued',
+                        });
+                    }
+                    else {
+                        const isOnline = this.tmuxService
+                            ? await this.tmuxService.hasSession(recipient.tmuxSessionId)
+                            : false;
+                        if (!isOnline) {
+                            queued.push({
+                                name: recipient.name,
+                                type: 'guest',
+                                status: 'failed',
+                                error: 'Recipient offline',
                             });
-                            session = launched;
-                            activeSessions.push(launched);
-                            wasLaunched = true;
                         }
-                        catch {
+                        else if (this.tmuxService) {
+                            try {
+                                await this.tmuxService.pasteAndSubmit(recipient.tmuxSessionId, injectionText);
+                                queued.push({
+                                    name: recipient.name,
+                                    type: 'guest',
+                                    status: 'delivered',
+                                });
+                            }
+                            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 {
+                            queued.push({
+                                name: recipient.name,
+                                type: 'guest',
+                                status: 'failed',
+                                error: 'Tmux service unavailable',
+                            });
                         }
                     }
-                    const injectionText = `\n[This message is sent from "${senderAgentName}" agent use devchain_send_message tool for communication]\n${validated.message}\n`;
-                    await this.messagePoolService.enqueue(agentId, injectionText, {
-                        source: 'mcp.send_message',
-                        submitKeys: ['Enter'],
-                        senderAgentId: senderAgentId,
-                        projectId: project.id,
-                        agentName: agent.name,
-                    });
-                    queued.push({
-                        agentName: agent.name,
-                        status: wasLaunched ? 'launched' : 'queued',
-                    });
                 }
                 const response = {
                     mode: 'pooled',
@@ -1425,11 +1585,11 @@ let McpService = class McpService {
                 };
             }
             let threadId = validated.threadId;
-            if (!threadId && senderAgentId) {
+            if (!threadId && senderId) {
                 if (recipientType === 'user') {
                     const direct = await this.chatService.createDirectThread({
                         projectId: project.id,
-                        agentId: senderAgentId,
+                        agentId: senderId,
                     });
                     threadId = direct.id;
                 }
@@ -1448,15 +1608,12 @@ let McpService = class McpService {
             const thread = await this.chatService.getThread(threadId);
             const message = await this.chatService.createMessage(threadId, {
                 authorType: 'agent',
-                authorAgentId: senderAgentId,
+                authorAgentId: senderId,
                 content: validated.message,
             });
-            let targetAgentIds = normalizedRecipientIds;
-            if (senderAgentId &&
-                thread.members &&
-                thread.members.length > 1 &&
-                targetAgentIds.length === 0) {
-                targetAgentIds = thread.members.filter((id) => id !== senderAgentId);
+            let targetAgentIds = uniqueRecipients.filter((r) => r.type === 'agent').map((r) => r.id);
+            if (senderId && thread.members && thread.members.length > 1 && targetAgentIds.length === 0) {
+                targetAgentIds = thread.members.filter((id) => id !== senderId);
             }
             const activeSessions = await this.sessionsService.listActiveSessions();
             const delivered = [];
@@ -1479,7 +1636,7 @@ let McpService = class McpService {
                     delivered.push({ agentId, agentName: agent.name, sessionId: '', status: 'queued' });
                     continue;
                 }
-                const injectionText = `\n[CHAT] From: ${senderAgentName} • 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 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`;
                 await this.sessionsService.injectTextIntoSession(session.id, injectionText);
                 delivered.push({
                     agentId,
@@ -1523,7 +1680,8 @@ let McpService = class McpService {
         const ctx = await this.resolveSessionContext(validated.sessionId);
         if (!ctx.success)
             return ctx;
-        const { agent } = ctx.data;
+        const sessionCtx = ctx.data;
+        const agent = getActorFromContext(sessionCtx);
         if (!agent) {
             return {
                 success: false,
@@ -1757,7 +1915,18 @@ let McpService = class McpService {
         const ctx = await this.resolveSessionContext(validated.sessionId);
         if (!ctx.success)
             return ctx;
-        const { project, agent } = ctx.data;
+        const sessionCtx = ctx.data;
+        const project = sessionCtx.project;
+        const agent = getActorFromContext(sessionCtx);
+        if (sessionCtx.type === 'guest') {
+            return {
+                success: false,
+                error: {
+                    code: 'GUEST_ACTIVITY_NOT_ALLOWED',
+                    message: 'Guests cannot use activity tools.',
+                },
+            };
+        }
         if (!project) {
             return {
                 success: false,
@@ -1818,7 +1987,18 @@ let McpService = class McpService {
         const ctx = await this.resolveSessionContext(validated.sessionId);
         if (!ctx.success)
             return ctx;
-        const { project, agent } = ctx.data;
+        const sessionCtx = ctx.data;
+        const project = sessionCtx.project;
+        const agent = getActorFromContext(sessionCtx);
+        if (sessionCtx.type === 'guest') {
+            return {
+                success: false,
+                error: {
+                    code: 'GUEST_ACTIVITY_NOT_ALLOWED',
+                    message: 'Guests cannot use activity tools.',
+                },
+            };
+        }
         if (!project) {
             return {
                 success: false,
@@ -1961,11 +2141,15 @@ let McpService = class McpService {
                 matchingSessions = activeSessions.filter((s) => s.id.startsWith(sessionId));
             }
             if (matchingSessions.length === 0) {
+                const guestContext = await this.tryResolveGuestContext(sessionId);
+                if (guestContext) {
+                    return { success: true, data: guestContext };
+                }
                 return {
                     success: false,
                     error: {
                         code: 'SESSION_NOT_FOUND',
-                        message: `No active session found matching '${sessionId}'`,
+                        message: `No active session or guest found matching '${sessionId}'`,
                     },
                 };
             }
@@ -2013,6 +2197,7 @@ let McpService = class McpService {
                 }
             }
             const context = {
+                type: 'agent',
                 session: {
                     id: session.id,
                     agentId: session.agentId,
@@ -2035,6 +2220,103 @@ let McpService = class McpService {
             };
         }
     }
+    async tryResolveGuestContext(guestId) {
+        if (!this.guestsService || !this.tmuxService) {
+            return null;
+        }
+        try {
+            let guest;
+            if (guestId.length === 36) {
+                guest = await this.storage.getGuest(guestId);
+            }
+            else {
+                const matches = await this.storage.getGuestsByIdPrefix(guestId);
+                if (matches.length === 1) {
+                    guest = matches[0];
+                }
+                else {
+                    return null;
+                }
+            }
+            const sessionAlive = await this.tmuxService.hasSession(guest.tmuxSessionId);
+            if (!sessionAlive) {
+                logger.warn({ guestId: guest.id, tmuxSessionId: guest.tmuxSessionId }, 'Guest tmux session no longer exists');
+                return null;
+            }
+            const project = await this.storage.getProject(guest.projectId);
+            const context = {
+                type: 'guest',
+                guest: {
+                    id: guest.id,
+                    name: guest.name,
+                    projectId: guest.projectId,
+                    tmuxSessionId: guest.tmuxSessionId,
+                },
+                project: {
+                    id: project.id,
+                    name: project.name,
+                    rootPath: project.rootPath,
+                },
+            };
+            return context;
+        }
+        catch (error) {
+            logger.debug({ guestId: redactSessionId(guestId), error: String(error) }, 'Failed to resolve guest context');
+            return null;
+        }
+    }
+    async registerGuest(params) {
+        if (!this.guestsService) {
+            return {
+                success: false,
+                error: {
+                    code: 'SERVICE_UNAVAILABLE',
+                    message: 'Guest registration requires full app context',
+                },
+            };
+        }
+        const validated = mcp_dto_1.RegisterGuestParamsSchema.parse(params);
+        try {
+            const result = await this.guestsService.register({
+                name: validated.name,
+                tmuxSessionId: validated.tmuxSessionId,
+                description: validated.description,
+            });
+            const response = {
+                guestId: result.guestId,
+                name: validated.name,
+                projectId: result.projectId,
+                projectName: result.projectName,
+                isSandbox: result.isSandbox,
+                registeredAt: new Date().toISOString(),
+            };
+            logger.info({ guestId: result.guestId, projectId: result.projectId, isSandbox: result.isSandbox }, 'Guest registered successfully');
+            return { success: true, data: response };
+        }
+        catch (error) {
+            if (error instanceof error_types_1.ValidationError) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'VALIDATION_ERROR',
+                        message: error.message,
+                        data: error.details,
+                    },
+                };
+            }
+            if (error instanceof Error && error.name === 'ConflictError') {
+                return {
+                    success: false,
+                    error: {
+                        code: 'CONFLICT',
+                        message: error.message,
+                        data: error.data,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
     mapStatusSummary(status) {
         return {
             id: status.id,
@@ -2364,13 +2646,17 @@ exports.McpService = McpService = __decorate([
     __param(2, (0, common_1.Inject)((0, common_1.forwardRef)(() => sessions_service_1.SessionsService))),
     __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => sessions_message_pool_service_1.SessionsMessagePoolService))),
     __param(4, (0, common_1.Inject)((0, common_1.forwardRef)(() => terminal_gateway_1.TerminalGateway))),
-    __param(5, (0, common_1.Inject)((0, common_1.forwardRef)(() => epics_service_1.EpicsService))),
-    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => settings_service_1.SettingsService))),
+    __param(5, (0, common_1.Inject)((0, common_1.forwardRef)(() => tmux_service_1.TmuxService))),
+    __param(6, (0, common_1.Inject)((0, common_1.forwardRef)(() => epics_service_1.EpicsService))),
+    __param(7, (0, common_1.Inject)((0, common_1.forwardRef)(() => settings_service_1.SettingsService))),
+    __param(8, (0, common_1.Inject)((0, common_1.forwardRef)(() => guests_service_1.GuestsService))),
     __metadata("design:paramtypes", [Object, chat_service_1.ChatService,
         sessions_service_1.SessionsService,
         sessions_message_pool_service_1.SessionsMessagePoolService,
         terminal_gateway_1.TerminalGateway,
+        tmux_service_1.TmuxService,
         epics_service_1.EpicsService,
-        settings_service_1.SettingsService])
+        settings_service_1.SettingsService,
+        guests_service_1.GuestsService])
 ], McpService);
 //# sourceMappingURL=mcp.service.js.map