GASSAPI MCP Server

Instructions

Implementation Reference

• src/tools/folders/handlers/folderHandlers.ts:276-352 (handler)

  Main handler function executing the update_folder tool. Validates input, initializes services, calls FolderService.updateFolder, and formats the MCP response.

  export async function handleUpdateFolder(args: any): Promise<McpToolResponse> {
    try {
      const { folderId, name, description, parentId } = args;
  
      if (!folderId) {
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                success: false,
                error: 'Folder ID is required'
              }, null, 2)
            }
          ]
        };
      }
  
      const instances = await getInstances();
  
      // Create folder service
      const folderService = new FolderService(
        instances.backendClient.getBaseUrl(),
        instances.backendClient.getToken()
      );
  
      // Update folder
      const updateRequest: UpdateFolderRequest = {
        folderId,
        name: name?.trim(),
        description: description?.trim(),
        parentId
      };
  
      const response = await folderService.updateFolder(updateRequest);
  
      if (!response.success) {
        return {
          content: [
            {
              type: 'text',
              text: JSON.stringify({
                success: false,
                error: response.error || 'Failed to update folder'
              }, null, 2)
            }
          ]
        };
      }
  
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              success: true,
              data: response.data,
              message: 'Folder updated successfully'
            }, null, 2)
          }
        ]
      };
  
    } catch (error: any) {
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify({
              success: false,
              error: error.message || 'Unknown error occurred while updating folder'
            }, null, 2)
          }
        ]
      };
    }
  }

• src/tools/folders/tools.ts:81-107 (schema)

  MCP tool definition for update_folder, including input schema, description, and handler reference.

  export const updateFolderTool: McpTool = {
    name: 'update_folder',
    description: 'Update folder name, description, or parent',
    inputSchema: {
      type: 'object',
      properties: {
        folderId: {
          type: 'string',
          description: 'Folder ID to update'
        },
        name: {
          type: 'string',
          description: 'New folder name'
        },
        description: {
          type: 'string',
          description: 'New folder description'
        },
        parentId: {
          type: 'string',
          description: 'New parent folder ID (null to move to root)'
        }
      },
      required: ['folderId']
    },
    handler: handleUpdateFolder
  };

• src/tools/index.ts:126-129 (registration)

  Registration of the update_folder handler in the main createFolderToolHandlers factory function, used by the MCP server.

  'update_folder': async (args: any) => {
    const { handleUpdateFolder } = await import('./folders/handlers/folderHandlers.js');
    return handleUpdateFolder(args);
  },

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

  TypeScript interface defining the UpdateFolderRequest used for input validation and typing.

  export interface UpdateFolderRequest {
    folderId: string;
    name?: string;
    description?: string;
    parentId?: string;
  }

• src/tools/folders/services/FolderService.ts:183-229 (helper)

  Helper service method in FolderService that performs the actual HTTP PUT request to the backend to update the folder.

  async updateFolder(request: UpdateFolderRequest): Promise<UpdateFolderResponse> {
    try {
      // Validate request
      const validation = this.validateUpdateRequest(request);
      if (!validation.valid) {
        return {
          success: false,
          error: 'Validation failed',
          details: validation.errors
        };
      }
  
      const url = `${this.baseUrl}/?act=folder_update&id=${request.folderId}`;
      const updateData: any = {};
  
      if (request.name !== undefined) {
        updateData.name = request.name.trim();
      }
      if (request.description !== undefined) {
        updateData.description = request.description?.trim() || null;
      }
      if (request.parentId !== undefined) {
        updateData.parent_id = request.parentId;
      }
  
      const response = await this.httpClient.put(url, updateData);
  
      if (response.success && response.data) {
        return {
          success: true,
          data: response.data,
          message: 'Folder updated successfully'
        };
      }
  
      return {
        success: false,
        error: response.error || 'Failed to update folder'
      };
  
    } catch (error) {
      return {
        success: false,
        error: ErrorUtils.extractMessage(error)
      };
    }
  }