GAM MCP Server
by dbarks
users.ts•11.5 kB
import { z } from 'zod';
import { GamExecutor, GamSchemas } from '../gam-executor.js';
/**
* User Management Tools for GAM MCP Server
* Provides comprehensive user administration capabilities
*/
const gam = new GamExecutor();
// Schema for user list parameters
const ListUsersSchema = z.object({
domain: GamSchemas.domain.optional(),
query: GamSchemas.query,
maxResults: GamSchemas.maxResults
});
// Schema for get user parameters
const GetUserSchema = z.object({
email: GamSchemas.email
});
// Schema for create user parameters
const CreateUserSchema = z.object({
email: GamSchemas.email,
firstName: GamSchemas.firstName,
lastName: GamSchemas.lastName,
password: GamSchemas.password,
orgUnit: GamSchemas.orgUnitPath.optional()
});
// Schema for update user parameters
const UpdateUserSchema = z.object({
email: GamSchemas.email,
updates: z.object({
firstName: GamSchemas.firstName.optional(),
lastName: GamSchemas.lastName.optional(),
orgUnit: GamSchemas.orgUnitPath.optional(),
suspended: z.boolean().optional()
}).refine(data => Object.keys(data).length > 0, {
message: 'At least one field must be provided for update'
})
});
// Schema for suspend/unsuspend user parameters
const SuspendUserSchema = z.object({
email: GamSchemas.email
});
// Schema for move user org unit parameters
const MoveUserOrgUnitSchema = z.object({
email: GamSchemas.email,
orgUnitPath: GamSchemas.orgUnitPath
});
/**
* List all users in the Google Workspace domain
*/
export const gam_list_users = {
name: 'gam_list_users',
description: 'List all users in the Google Workspace domain with optional filtering',
inputSchema: ListUsersSchema,
handler: async (params: z.infer<typeof ListUsersSchema>) => {
try {
const args = ['print', 'users'];
if (params.domain) {
args.push('domain', params.domain);
}
if (params.query) {
args.push('query', params.query);
}
if (params.maxResults) {
args.push('limit', params.maxResults.toString());
}
args.push('fields', 'primaryEmail,firstName,lastName,isAdmin,isEnforcedIn2Sv,isEnrolledIn2Sv,isMailboxSetup,creationTime,lastLoginTime,orgUnitPath,suspended');
const result = await gam.executeCommandWithCsv(args);
if (!result.success) {
return {
success: false,
error: result.error || 'Failed to list users',
data: null
};
}
const users = result.parsedData.map(user => ({
email: user['primaryEmail'],
firstName: user['firstName'],
lastName: user['lastName'],
isAdmin: user['isAdmin'] === 'True',
isEnforcedIn2Sv: user['isEnforcedIn2Sv'] === 'True',
isEnrolledIn2Sv: user['isEnrolledIn2Sv'] === 'True',
isMailboxSetup: user['isMailboxSetup'] === 'True',
creationTime: user['creationTime'],
lastLoginTime: user['lastLoginTime'],
orgUnitPath: user['orgUnitPath'],
suspended: user['suspended'] === 'True'
}));
return {
success: true,
data: {
users,
totalCount: users.length,
executionTime: result.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
/**
* Get detailed information about a specific user
*/
export const gam_get_user = {
name: 'gam_get_user',
description: 'Get detailed information about a specific user including groups, aliases, and settings',
inputSchema: GetUserSchema,
handler: async (params: z.infer<typeof GetUserSchema>) => {
try {
// Get basic user info
const userArgs = ['show', 'user', params.email];
const userResult = await gam.executeCommandWithCsv(userArgs);
if (!userResult.success) {
return {
success: false,
error: userResult.error || 'Failed to get user information',
data: null
};
}
// Get user groups
const groupsArgs = ['print', 'users', 'query', `email:${params.email}`, 'groups'];
const groupsResult = await gam.executeCommandWithCsv(groupsArgs);
// Get user aliases
const aliasesArgs = ['print', 'users', 'query', `email:${params.email}`, 'aliases'];
const aliasesResult = await gam.executeCommandWithCsv(aliasesArgs);
const userData = userResult.parsedData[0] || {};
const groups = groupsResult.success ? groupsResult.parsedData : [];
const aliases = aliasesResult.success ? aliasesResult.parsedData : [];
return {
success: true,
data: {
email: userData['primaryEmail'],
firstName: userData['firstName'],
lastName: userData['lastName'],
isAdmin: userData['isAdmin'] === 'True',
isEnforcedIn2Sv: userData['isEnforcedIn2Sv'] === 'True',
isEnrolledIn2Sv: userData['isEnrolledIn2Sv'] === 'True',
isMailboxSetup: userData['isMailboxSetup'] === 'True',
creationTime: userData['creationTime'],
lastLoginTime: userData['lastLoginTime'],
orgUnitPath: userData['orgUnitPath'],
suspended: userData['suspended'] === 'True',
groups: groups.map(g => g['email']),
aliases: aliases.map(a => a['alias']),
executionTime: userResult.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
/**
* Create a new user in Google Workspace
*/
export const gam_create_user = {
name: 'gam_create_user',
description: 'Create a new user in Google Workspace with specified details',
inputSchema: CreateUserSchema,
handler: async (params: z.infer<typeof CreateUserSchema>) => {
try {
const args = ['create', 'user', params.email, 'firstname', params.firstName, 'lastname', params.lastName];
if (params.password) {
args.push('password', params.password);
}
if (params.orgUnit) {
args.push('ou', params.orgUnit);
}
const result = await gam.executeCommand(args);
if (!result.success) {
return {
success: false,
error: result.error || 'Failed to create user',
data: null
};
}
return {
success: true,
data: {
email: params.email,
message: 'User created successfully',
executionTime: result.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
/**
* Update user properties
*/
export const gam_update_user = {
name: 'gam_update_user',
description: 'Update user properties such as name, org unit, or suspension status',
inputSchema: UpdateUserSchema,
handler: async (params: z.infer<typeof UpdateUserSchema>) => {
try {
const args = ['update', 'user', params.email];
if (params.updates.firstName) {
args.push('firstname', params.updates.firstName);
}
if (params.updates.lastName) {
args.push('lastname', params.updates.lastName);
}
if (params.updates.orgUnit) {
args.push('ou', params.updates.orgUnit);
}
if (params.updates.suspended !== undefined) {
args.push('suspended', params.updates.suspended ? 'true' : 'false');
}
const result = await gam.executeCommand(args);
if (!result.success) {
return {
success: false,
error: result.error || 'Failed to update user',
data: null
};
}
return {
success: true,
data: {
email: params.email,
message: 'User updated successfully',
executionTime: result.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
/**
* Suspend a user account
*/
export const gam_suspend_user = {
name: 'gam_suspend_user',
description: 'Suspend a user account, preventing login and access to services',
inputSchema: SuspendUserSchema,
handler: async (params: z.infer<typeof SuspendUserSchema>) => {
try {
const args = ['update', 'user', params.email, 'suspended', 'true'];
const result = await gam.executeCommand(args);
if (!result.success) {
return {
success: false,
error: result.error || 'Failed to suspend user',
data: null
};
}
return {
success: true,
data: {
email: params.email,
message: 'User suspended successfully',
executionTime: result.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
/**
* Unsuspend a user account
*/
export const gam_unsuspend_user = {
name: 'gam_unsuspend_user',
description: 'Unsuspend a user account, restoring login and access to services',
inputSchema: SuspendUserSchema,
handler: async (params: z.infer<typeof SuspendUserSchema>) => {
try {
const args = ['update', 'user', params.email, 'suspended', 'false'];
const result = await gam.executeCommand(args);
if (!result.success) {
return {
success: false,
error: result.error || 'Failed to unsuspend user',
data: null
};
}
return {
success: true,
data: {
email: params.email,
message: 'User unsuspended successfully',
executionTime: result.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
/**
* Move a user to a different organizational unit
*/
export const gam_move_user_orgunit = {
name: 'gam_move_user_orgunit',
description: 'Move a user to a different organizational unit',
inputSchema: MoveUserOrgUnitSchema,
handler: async (params: z.infer<typeof MoveUserOrgUnitSchema>) => {
try {
const args = ['update', 'user', params.email, 'ou', params.orgUnitPath];
const result = await gam.executeCommand(args);
if (!result.success) {
return {
success: false,
error: result.error || 'Failed to move user to new org unit',
data: null
};
}
return {
success: true,
data: {
email: params.email,
newOrgUnit: params.orgUnitPath,
message: 'User moved to new org unit successfully',
executionTime: result.executionTime
},
error: null
};
} catch (error) {
return {
success: false,
error: error instanceof Error ? error.message : 'Unknown error occurred',
data: null
};
}
}
};
Latest Blog Posts
- MCP Moves to the Linux Foundation: Neutral Stewardship for Agentic InfrastructureBy Om-Shree-0709 on .mcpanthropicLinux Foundation
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/dbarks/mcp-gam'
If you have feedback or need assistance with the MCP directory API, please join our Discord server