devchain-cli 0.12.4 → 0.13.1

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

@@ -6,22 +6,10 @@ exports.handleTeamsConfigsList = handleTeamsConfigsList;
 exports.handleTeamsCreateAgent = handleTeamsCreateAgent;
 exports.handleTeamsDeleteAgent = handleTeamsDeleteAgent;
 exports.handleDevchainTeam = handleDevchainTeam;
-const mcp_dto_1 = require("../../dtos/mcp.dto");
-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);
-}
+const service_unavailable_error_1 = require("../../../../common/errors/service-unavailable.error");
+const session_context_helpers_1 = require("../utils/session-context-helpers");
+const agent_name_resolver_1 = require("../utils/agent-name-resolver");
+const require_project_1 = require("../utils/require-project");
 function teamsServiceUnavailable() {
     return {
         success: false,
@@ -31,49 +19,46 @@ function teamsServiceUnavailable() {
         },
     };
 }
-async function handleTeamsList(ctx, params) {
-    if (!ctx.teamsService) {
+function catchTeamsUnavailable(error) {
+    if (error instanceof service_unavailable_error_1.ServiceUnavailableError) {
         return teamsServiceUnavailable();
     }
-    const validated = mcp_dto_1.TeamsListParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
-    if (!sessionCtxResult.success)
-        return sessionCtxResult;
-    const { project } = sessionCtxResult.data;
-    if (!project) {
-        return {
-            success: false,
-            error: {
-                code: 'PROJECT_NOT_FOUND',
-                message: 'No project associated with this session',
-            },
-        };
-    }
+    throw error;
+}
+async function handleTeamsList(ctx, params) {
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
+    const projectResult = (0, require_project_1.requireProject)(sessionCtxResult);
+    if (!('project' in projectResult))
+        return projectResult;
+    const { project } = projectResult;
     const limit = validated.limit ?? 100;
     const offset = validated.offset ?? 0;
-    const result = await ctx.teamsService.listTeams(project.id, { limit, offset, q: validated.q });
-    const teams = result.items.map((t) => ({
-        id: t.id,
-        name: t.name,
-        description: t.description,
-        teamLeadAgentId: t.teamLeadAgentId,
-        teamLeadName: t.teamLeadAgentName,
-        memberCount: t.memberCount,
-    }));
-    const response = {
-        teams,
-        total: result.total,
-        limit,
-        offset,
-    };
-    return { success: true, data: response };
+    try {
+        const result = await ctx.teamsService.listTeams(project.id, { limit, offset, q: validated.q });
+        const teams = result.items.map((t) => ({
+            id: t.id,
+            name: t.name,
+            description: t.description,
+            teamLeadAgentId: t.teamLeadAgentId,
+            teamLeadName: t.teamLeadAgentName,
+            memberCount: t.memberCount,
+        }));
+        const response = {
+            teams,
+            total: result.total,
+            limit,
+            offset,
+        };
+        return { success: true, data: response };
+    }
+    catch (error) {
+        return catchTeamsUnavailable(error);
+    }
 }
 async function handleTeamsMembersList(ctx, params) {
-    if (!ctx.teamsService) {
-        return teamsServiceUnavailable();
-    }
-    const validated = mcp_dto_1.TeamsMembersListParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
     if (!sessionCtxResult.success)
         return sessionCtxResult;
     const sessionCtx = sessionCtxResult.data;
@@ -87,81 +72,83 @@ async function handleTeamsMembersList(ctx, params) {
             },
         };
     }
-    if (validated.teamId) {
-        const team = await ctx.teamsService.getTeam(validated.teamId);
-        if (!team) {
+    try {
+        if (validated.teamId) {
+            const team = await ctx.teamsService.getTeam(validated.teamId);
+            if (!team) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'TEAM_NOT_FOUND',
+                        message: `Team ${validated.teamId} was not found.`,
+                    },
+                };
+            }
+            if (team.projectId !== project.id) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'TEAM_NOT_FOUND',
+                        message: `Team ${validated.teamId} does not belong to the resolved project.`,
+                    },
+                };
+            }
+            const members = await buildTeamMembers(ctx, team.members, team.teamLeadAgentId);
+            const response = {
+                teams: [
+                    {
+                        teamId: team.id,
+                        teamName: team.name,
+                        members,
+                    },
+                ],
+            };
+            return { success: true, data: response };
+        }
+        if (sessionCtx.type === 'guest') {
             return {
                 success: false,
                 error: {
-                    code: 'TEAM_NOT_FOUND',
-                    message: `Team ${validated.teamId} was not found.`,
+                    code: 'AGENT_CONTEXT_REQUIRED',
+                    message: 'Guest sessions must provide teamId. Guests do not have team membership.',
                 },
             };
         }
-        if (team.projectId !== project.id) {
+        const agentCtx = sessionCtx;
+        if (!agentCtx.agent) {
             return {
                 success: false,
                 error: {
-                    code: 'TEAM_NOT_FOUND',
-                    message: `Team ${validated.teamId} does not belong to the resolved project.`,
+                    code: 'AGENT_REQUIRED',
+                    message: 'Session must be associated with an agent to list team membership',
                 },
             };
         }
-        const members = await buildTeamMembers(ctx, team.members, team.teamLeadAgentId);
+        const agentTeams = await ctx.teamsService.listTeamsByAgent(agentCtx.agent.id);
+        const teamsEntries = [];
+        for (const team of agentTeams) {
+            const fullTeam = await ctx.teamsService.getTeam(team.id);
+            if (!fullTeam)
+                continue;
+            const members = await buildTeamMembers(ctx, fullTeam.members, fullTeam.teamLeadAgentId);
+            teamsEntries.push({
+                teamId: fullTeam.id,
+                teamName: fullTeam.name,
+                members,
+            });
+        }
         const response = {
-            teams: [
-                {
-                    teamId: team.id,
-                    teamName: team.name,
-                    members,
-                },
-            ],
+            teams: teamsEntries,
         };
         return { success: true, data: response };
     }
-    if (sessionCtx.type === 'guest') {
-        return {
-            success: false,
-            error: {
-                code: 'AGENT_CONTEXT_REQUIRED',
-                message: 'Guest sessions must provide teamId. Guests do not have team membership.',
-            },
-        };
+    catch (error) {
+        return catchTeamsUnavailable(error);
     }
-    const agentCtx = sessionCtx;
-    if (!agentCtx.agent) {
-        return {
-            success: false,
-            error: {
-                code: 'AGENT_REQUIRED',
-                message: 'Session must be associated with an agent to list team membership',
-            },
-        };
-    }
-    const agentTeams = await ctx.teamsService.listTeamsByAgent(agentCtx.agent.id);
-    const teamsEntries = [];
-    for (const team of agentTeams) {
-        const fullTeam = await ctx.teamsService.getTeam(team.id);
-        if (!fullTeam)
-            continue;
-        const members = await buildTeamMembers(ctx, fullTeam.members, fullTeam.teamLeadAgentId);
-        teamsEntries.push({
-            teamId: fullTeam.id,
-            teamName: fullTeam.name,
-            members,
-        });
-    }
-    const response = {
-        teams: teamsEntries,
-    };
-    return { success: true, data: response };
 }
 async function handleTeamsConfigsList(ctx, params) {
-    if (!ctx.teamsService) {
-        return teamsServiceUnavailable();
-    }
-    const parsed = mcp_dto_1.TeamsConfigsListParamsSchema.parse(params);
-    const sessionResult = await resolveSessionContext(ctx, parsed.sessionId);
+    const parsed = params;
+    const sessionResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, parsed.sessionId);
     if (!sessionResult.success)
         return sessionResult;
     const sessionCtx = sessionResult.data;
@@ -193,17 +180,19 @@ async function handleTeamsConfigsList(ctx, params) {
             },
         };
     }
-    const result = await ctx.teamsService.listConfigsVisibleToLead(agentCtx.agent.id, agentCtx.project.id);
-    if ('error' in result)
-        return { success: false, error: result.error };
-    return { success: true, data: { configs: result } };
+    try {
+        const result = await ctx.teamsService.listConfigsVisibleToLead(agentCtx.agent.id, agentCtx.project.id);
+        if ('error' in result)
+            return { success: false, error: result.error };
+        return { success: true, data: { configs: result } };
+    }
+    catch (error) {
+        return catchTeamsUnavailable(error);
+    }
 }
 async function handleTeamsCreateAgent(ctx, params) {
-    if (!ctx.teamsService) {
-        return teamsServiceUnavailable();
-    }
-    const parsed = mcp_dto_1.TeamsCreateAgentParamsSchema.parse(params);
-    const sessionResult = await resolveSessionContext(ctx, parsed.sessionId);
+    const parsed = params;
+    const sessionResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, parsed.sessionId);
     if (!sessionResult.success)
         return sessionResult;
     const sessionCtx = sessionResult.data;
@@ -235,25 +224,27 @@ async function handleTeamsCreateAgent(ctx, params) {
             },
         };
     }
-    const result = await ctx.teamsService.createTeamAgent({
-        leadAgentId: agentCtx.agent.id,
-        projectId: agentCtx.project.id,
-        name: parsed.name,
-        description: parsed.description,
-        configName: parsed.configName,
-        profileName: parsed.profileName,
-        teamName: parsed.teamName,
-    });
-    if ('error' in result)
-        return { success: false, error: result.error };
-    return { success: true, data: result };
+    try {
+        const result = await ctx.teamsService.createTeamAgent({
+            leadAgentId: agentCtx.agent.id,
+            projectId: agentCtx.project.id,
+            name: parsed.name,
+            description: parsed.description,
+            configName: parsed.configName,
+            profileName: parsed.profileName,
+            teamName: parsed.teamName,
+        });
+        if ('error' in result)
+            return { success: false, error: result.error };
+        return { success: true, data: result };
+    }
+    catch (error) {
+        return catchTeamsUnavailable(error);
+    }
 }
 async function handleTeamsDeleteAgent(ctx, params) {
-    if (!ctx.teamsService) {
-        return teamsServiceUnavailable();
-    }
-    const parsed = mcp_dto_1.TeamsDeleteAgentParamsSchema.parse(params);
-    const sessionResult = await resolveSessionContext(ctx, parsed.sessionId);
+    const parsed = params;
+    const sessionResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, parsed.sessionId);
     if (!sessionResult.success)
         return sessionResult;
     const sessionCtx = sessionResult.data;
@@ -285,40 +276,33 @@ async function handleTeamsDeleteAgent(ctx, params) {
             },
         };
     }
-    const result = await ctx.teamsService.deleteTeamAgent({
-        leadAgentId: agentCtx.agent.id,
-        projectId: agentCtx.project.id,
-        name: parsed.name,
-        teamName: parsed.teamName,
-    });
-    if ('error' in result)
-        return { success: false, error: result.error };
-    return { success: true, data: result.result };
-}
-async function buildTeamMembers(ctx, members, teamLeadAgentId) {
-    const result = [];
-    for (const member of members) {
-        let agentName = member.agentId;
-        try {
-            const agent = await ctx.storage.getAgent(member.agentId);
-            agentName = agent.name;
-        }
-        catch {
-        }
-        result.push({
-            agentId: member.agentId,
-            agentName,
-            isTeamLead: member.agentId === teamLeadAgentId,
+    try {
+        const result = await ctx.teamsService.deleteTeamAgent({
+            leadAgentId: agentCtx.agent.id,
+            projectId: agentCtx.project.id,
+            name: parsed.name,
+            teamName: parsed.teamName,
         });
+        if ('error' in result)
+            return { success: false, error: result.error };
+        return { success: true, data: result.result };
+    }
+    catch (error) {
+        return catchTeamsUnavailable(error);
     }
-    return result;
+}
+async function buildTeamMembers(ctx, members, teamLeadAgentId) {
+    const agentIds = new Set(members.map((m) => m.agentId));
+    const agentNameById = await (0, agent_name_resolver_1.resolveAgentNames)(ctx.storage, agentIds);
+    return members.map((member) => ({
+        agentId: member.agentId,
+        agentName: agentNameById.get(member.agentId) ?? member.agentId,
+        isTeamLead: member.agentId === teamLeadAgentId,
+    }));
 }
 async function handleDevchainTeam(ctx, params) {
-    if (!ctx.teamsService) {
-        return teamsServiceUnavailable();
-    }
-    const validated = mcp_dto_1.DevchainTeamParamsSchema.parse(params);
-    const sessionCtxResult = await resolveSessionContext(ctx, validated.sessionId);
+    const validated = params;
+    const sessionCtxResult = await (0, session_context_helpers_1.resolveSessionContext)(ctx, validated.sessionId);
     if (!sessionCtxResult.success)
         return sessionCtxResult;
     const sessionCtx = sessionCtxResult.data;
@@ -339,119 +323,128 @@ async function handleDevchainTeam(ctx, params) {
             },
         };
     }
-    let teamId;
-    if (validated.teamName) {
-        const team = await ctx.teamsService.findTeamByExactName(project.id, validated.teamName);
-        if (!team) {
-            return {
-                success: false,
-                error: { code: 'TEAM_NOT_FOUND', message: `Team "${validated.teamName}" not found` },
-            };
-        }
-        const detail = await ctx.teamsService.getTeam(team.id);
-        if (!detail) {
-            return {
-                success: false,
-                error: { code: 'TEAM_NOT_FOUND', message: `Team "${validated.teamName}" not found` },
-            };
-        }
-        const isMember = detail.members.some((m) => m.agentId === agent.id);
-        if (!isMember) {
-            return {
-                success: false,
-                error: { code: 'NOT_A_MEMBER', message: 'You are not a member of this team' },
-            };
+    try {
+        let teamId;
+        if (validated.teamName) {
+            const team = await ctx.teamsService.findTeamByExactName(project.id, validated.teamName);
+            if (!team) {
+                return {
+                    success: false,
+                    error: { code: 'TEAM_NOT_FOUND', message: `Team "${validated.teamName}" not found` },
+                };
+            }
+            const detail = await ctx.teamsService.getTeam(team.id);
+            if (!detail) {
+                return {
+                    success: false,
+                    error: { code: 'TEAM_NOT_FOUND', message: `Team "${validated.teamName}" not found` },
+                };
+            }
+            const isMember = detail.members.some((m) => m.agentId === agent.id);
+            if (!isMember) {
+                return {
+                    success: false,
+                    error: { code: 'NOT_A_MEMBER', message: 'You are not a member of this team' },
+                };
+            }
+            teamId = team.id;
         }
-        teamId = team.id;
-    }
-    else {
-        const teams = await ctx.teamsService.listTeamsByAgent(agent.id);
-        if (teams.length === 0) {
-            return {
-                success: false,
-                error: { code: 'NOT_IN_ANY_TEAM', message: 'You do not belong to any team' },
-            };
+        else {
+            const teams = await ctx.teamsService.listTeamsByAgent(agent.id);
+            if (teams.length === 0) {
+                return {
+                    success: false,
+                    error: { code: 'NOT_IN_ANY_TEAM', message: 'You do not belong to any team' },
+                };
+            }
+            if (teams.length > 1) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'AMBIGUOUS_TEAM',
+                        message: `You belong to ${teams.length} teams. Specify teamName to disambiguate.`,
+                        data: { candidates: teams.map((t) => ({ teamName: t.name })) },
+                    },
+                };
+            }
+            teamId = teams[0].id;
         }
-        if (teams.length > 1) {
+        const detail = await ctx.teamsService.getTeam(teamId);
+        if (!detail) {
             return {
                 success: false,
-                error: {
-                    code: 'AMBIGUOUS_TEAM',
-                    message: `You belong to ${teams.length} teams. Specify teamName to disambiguate.`,
-                    data: { candidates: teams.map((t) => ({ teamName: t.name })) },
-                },
+                error: { code: 'TEAM_NOT_FOUND', message: 'Team not found' },
             };
         }
-        teamId = teams[0].id;
-    }
-    const detail = await ctx.teamsService.getTeam(teamId);
-    if (!detail) {
-        return {
-            success: false,
-            error: { code: 'TEAM_NOT_FOUND', message: 'Team not found' },
-        };
-    }
-    const members = [];
-    for (const m of detail.members) {
-        let agentName = m.agentId;
-        let profileId = null;
-        let profileName = null;
-        let providerConfigId = null;
-        let providerConfigName = null;
-        try {
-            const agentRecord = await ctx.storage.getAgent(m.agentId);
-            agentName = agentRecord.name;
-            profileId = agentRecord.profileId;
-            providerConfigId = agentRecord.providerConfigId;
-            if (profileId) {
-                try {
-                    const profile = await ctx.storage.getAgentProfile(profileId);
-                    profileName = profile.name;
+        const memberAgentIds = new Set(detail.members.map((m) => m.agentId));
+        const agentNameById = await (0, agent_name_resolver_1.resolveAgentNames)(ctx.storage, memberAgentIds);
+        const members = [];
+        for (const m of detail.members) {
+            let agentDescription = null;
+            let profileId = null;
+            let profileName = null;
+            let providerConfigId = null;
+            let providerConfigName = null;
+            const agentName = agentNameById.get(m.agentId) ?? m.agentId;
+            try {
+                const agentRecord = await ctx.storage.getAgent(m.agentId);
+                agentDescription = agentRecord.description;
+                profileId = agentRecord.profileId;
+                providerConfigId = agentRecord.providerConfigId;
+                if (profileId) {
+                    try {
+                        const profile = await ctx.storage.getAgentProfile(profileId);
+                        profileName = profile.name;
+                    }
+                    catch {
+                    }
                 }
-                catch {
+                if (providerConfigId) {
+                    try {
+                        const config = await ctx.storage.getProfileProviderConfig(providerConfigId);
+                        providerConfigName = config.name;
+                    }
+                    catch {
+                    }
                 }
             }
-            if (providerConfigId) {
-                try {
-                    const config = await ctx.storage.getProfileProviderConfig(providerConfigId);
-                    providerConfigName = config.name;
-                }
-                catch {
-                }
+            catch {
             }
+            members.push({
+                agentId: m.agentId,
+                agentName,
+                description: agentDescription,
+                isLead: m.agentId === detail.teamLeadAgentId,
+                profileId,
+                profileName,
+                providerConfigId,
+                providerConfigName,
+            });
         }
-        catch {
-        }
-        members.push({
-            agentId: m.agentId,
-            agentName,
-            isLead: m.agentId === detail.teamLeadAgentId,
-            profileId,
-            profileName,
-            providerConfigId,
-            providerConfigName,
-        });
+        const busyMembersCount = await ctx.teamsService.countBusyTeamMembers(teamId, detail.teamLeadAgentId);
+        const currentMemberCount = members.filter((m) => !m.isLead).length;
+        const leadMember = members.find((m) => m.isLead);
+        const response = {
+            id: detail.id,
+            name: detail.name,
+            description: detail.description,
+            teamLeadAgentId: detail.teamLeadAgentId,
+            teamLeadAgentName: leadMember?.agentName ?? null,
+            members,
+            maxMembers: detail.maxMembers,
+            maxConcurrentTasks: detail.maxConcurrentTasks,
+            allowTeamLeadCreateAgents: detail.allowTeamLeadCreateAgents,
+            currentMemberCount,
+            busyMembersCount,
+            freeSeats: Math.max(0, detail.maxMembers - currentMemberCount),
+            freeConcurrentSlots: Math.max(0, detail.maxConcurrentTasks - busyMembersCount),
+            createdAt: detail.createdAt,
+            updatedAt: detail.updatedAt,
+        };
+        return { success: true, data: response };
+    }
+    catch (error) {
+        return catchTeamsUnavailable(error);
     }
-    const busyMembersCount = await ctx.teamsService.countBusyTeamMembers(teamId, detail.teamLeadAgentId);
-    const currentMemberCount = members.filter((m) => !m.isLead).length;
-    const leadMember = members.find((m) => m.isLead);
-    const response = {
-        id: detail.id,
-        name: detail.name,
-        description: detail.description,
-        teamLeadAgentId: detail.teamLeadAgentId,
-        teamLeadAgentName: leadMember?.agentName ?? null,
-        members,
-        maxMembers: detail.maxMembers,
-        maxConcurrentTasks: detail.maxConcurrentTasks,
-        allowTeamLeadCreateAgents: detail.allowTeamLeadCreateAgents,
-        currentMemberCount,
-        busyMembersCount,
-        freeSeats: Math.max(0, detail.maxMembers - currentMemberCount),
-        freeConcurrentSlots: Math.max(0, detail.maxConcurrentTasks - busyMembersCount),
-        createdAt: detail.createdAt,
-        updatedAt: detail.updatedAt,
-    };
-    return { success: true, data: response };
 }
 //# sourceMappingURL=teams-tools.js.map