GASSAPI MCP Server

Instructions

Implementation Reference

• src/tools/folders/handlers/folderHandlers.ts:175-270 (handler)

  Core handler function that executes the create_folder tool logic: validates arguments, initializes config and backend client, creates FolderService instance, calls backend API to create folder, handles errors, and returns standardized MCP tool response.

  export async function handleCreateFolder(args: any): Promise<McpToolResponse> {
    try {
      const { name, description, parentId, projectId } = args;
  
      if (!name) {
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                success: false,
                error: 'Folder name is required'
              }, null, 2)
            }
          ]
        };
      }
  
      const instances = await getInstances();
  
      // Get project ID if not provided
      let targetProjectId = projectId;
      if (!targetProjectId) {
        const config = await instances.configManager.detectProjectConfig();
        targetProjectId = config?.project?.id;
        if (!targetProjectId) {
          return {
            content: [
              {
                type: 'text',
                text: JSON.stringify({
                  success: false,
                  error: 'Project ID not found in config and not provided in arguments'
                }, null, 2)
              }
            ]
          };
        }
      }
  
      // Create folder service
      const folderService = new FolderService(
        instances.backendClient.getBaseUrl(),
        instances.backendClient.getToken()
      );
  
      // Create folder
      const createRequest: CreateFolderRequest = {
        name: name.trim(),
        description: description?.trim(),
        parentId,
        projectId: targetProjectId
      };
  
      const response = await folderService.createFolder(createRequest);
  
      if (!response.success) {
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                success: false,
                error: response.error || 'Failed to create folder'
              }, null, 2)
            }
          ]
        };
      }
  
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              success: true,
              data: response.data,
              message: 'Folder created successfully'
            }, null, 2)
          }
        ]
      };
  
    } catch (error: any) {
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              success: false,
              error: error.message || 'Unknown error occurred while creating folder'
            }, null, 2)
          }
        ]
      };
    }

• src/tools/folders/tools.ts:50-76 (schema)

  Defines the MCP tool schema for 'create_folder' including input validation schema with required 'name' field and optional description, parentId, projectId.

  export const createFolderTool: McpTool = {
    name: 'create_folder',
    description: 'Create a new folder in the project',
    inputSchema: {
      type: 'object',
      properties: {
        name: {
          type: 'string',
          description: 'Folder name'
        },
        description: {
          type: 'string',
          description: 'Folder description'
        },
        parentId: {
          type: 'string',
          description: 'Parent folder ID (optional, creates root-level folder if not provided)'
        },
        projectId: {
          type: 'string',
          description: 'Project ID (optional, will use current project if not provided)'
        }
      },
      required: ['name']
    },
    handler: handleCreateFolder
  };

• src/tools/index.ts:116-143 (registration)

  Registers the create_folder handler wrapper that dynamically imports and delegates to the core handleCreateFolder function. This function is spread into the main tool handlers registry.

  function createFolderToolHandlers(): Record<string, (args: any) => Promise<McpToolResponse>> {
    return {
      'list_folders': async (args: any) => {
        const { handleListFolders } = await import('./folders/handlers/folderHandlers.js');
        return handleListFolders(args);
      },
      'create_folder': async (args: any) => {
        const { handleCreateFolder } = await import('./folders/handlers/folderHandlers.js');
        return handleCreateFolder(args);
      },
      'update_folder': async (args: any) => {
        const { handleUpdateFolder } = await import('./folders/handlers/folderHandlers.js');
        return handleUpdateFolder(args);
      },
      'move_folder': async (args: any) => {
        const { handleMoveFolder } = await import('./folders/handlers/folderHandlers.js');
        return handleMoveFolder(args);
      },
      'delete_folder': async (args: any) => {
        const { handleDeleteFolder } = await import('./folders/handlers/folderHandlers.js');
        return handleDeleteFolder(args);
      },
      'get_folder_details': async (args: any) => {
        const { handleGetFolderDetails } = await import('./folders/handlers/folderHandlers.js');
        return handleGetFolderDetails(args);
      }
    };
  }

• src/tools/index.ts:30-38 (registration)

  Main tools registry array that includes folderTools (containing create_folder tool definition) among all available MCP tools.

  export const ALL_TOOLS: McpTool[] = [
    ...CORE_TOOLS,
    ...AUTH_TOOLS,
    ...environmentTools,
    ...folderTools,
    ...ENDPOINT_TOOLS,
    ...testingTools,
    ...flowTools
  ];