AutoProbeMCP

Instructions

Implementation Reference

• src/index.ts:78-80 (schema)

  Defines the Zod schema for validating input parameters of the check_scrollability tool, specifying the direction to check ('vertical', 'horizontal', or 'both').

  const CheckScrollabilitySchema = z.object({
    direction: z.enum(['vertical', 'horizontal', 'both']).default('both')
  });

• src/index.ts:387-401 (registration)

  Registers the check_scrollability tool in the MCP server's list of tools, providing its name, description, and input schema for the ListToolsRequest.

  {
    name: 'check_scrollability',
    description: 'Check if the page is scrollable in the specified direction',
    inputSchema: {
      type: 'object',
      properties: {
        direction: {
          type: 'string',
          enum: ['vertical', 'horizontal', 'both'],
          default: 'both',
          description: 'Direction to check for scrollability'
        }
      }
    }
  }

• src/index.ts:809-907 (handler)

  Handler function within the tool dispatch switch statement. Parses input, evaluates JavaScript on the page to compute document vs viewport dimensions and current scroll positions, determines scrollability in vertical/horizontal directions, and returns a formatted text response describing the scroll status.

            case 'check_scrollability': {
              if (!currentPage) {
                throw new Error('No browser page available. Launch a browser first.');
              }
  
              const params = CheckScrollabilitySchema.parse(args);
              const { direction } = params;
  
              // Check scrollability with proper typing
              const scrollInfo = await currentPage.evaluate((dir) => {
                const documentHeight = Math.max(
                  document.body.scrollHeight,
                  document.body.offsetHeight,
                  document.documentElement.clientHeight,
                  document.documentElement.scrollHeight,
                  document.documentElement.offsetHeight
                );
                
                const documentWidth = Math.max(
                  document.body.scrollWidth,
                  document.body.offsetWidth,
                  document.documentElement.clientWidth,
                  document.documentElement.scrollWidth,
                  document.documentElement.offsetWidth
                );
                
                const viewportHeight = window.innerHeight;
                const viewportWidth = window.innerWidth;
                
                const verticalScrollable = documentHeight > viewportHeight;
                const horizontalScrollable = documentWidth > viewportWidth;
                
                const currentScrollY = window.scrollY;
                const currentScrollX = window.scrollX;
                const maxScrollY = Math.max(0, documentHeight - viewportHeight);
                const maxScrollX = Math.max(0, documentWidth - viewportWidth);
                
                const verticalInfo = {
                  scrollable: verticalScrollable,
                  currentPosition: currentScrollY,
                  maxScroll: maxScrollY,
                  canScrollDown: currentScrollY < maxScrollY,
                  canScrollUp: currentScrollY > 0
                };
                
                const horizontalInfo = {
                  scrollable: horizontalScrollable,
                  currentPosition: currentScrollX,
                  maxScroll: maxScrollX,
                  canScrollRight: currentScrollX < maxScrollX,
                  canScrollLeft: currentScrollX > 0
                };
                
                return {
                  direction: dir,
                  vertical: verticalInfo,
                  horizontal: horizontalInfo,
                  anyScrollable: verticalScrollable || horizontalScrollable
                };
              }, direction);
  
              // Format the response message based on direction
              let message = '';
              
              if (direction === 'both') {
                const v = scrollInfo.vertical;
                const h = scrollInfo.horizontal;
                message = `Page scrollability status:
  Vertical: ${v.scrollable ? 'Scrollable' : 'Not scrollable'}${v.scrollable ? ` (${v.currentPosition}/${v.maxScroll})` : ''}
  Horizontal: ${h.scrollable ? 'Scrollable' : 'Not scrollable'}${h.scrollable ? ` (${h.currentPosition}/${h.maxScroll})` : ''}
  Overall: ${scrollInfo.anyScrollable ? 'Page is scrollable' : 'Page is not scrollable'}`;
              } else if (direction === 'vertical') {
                const v = scrollInfo.vertical;
                message = `Vertical scrolling: ${v.scrollable ? 'Available' : 'Not available'}`;
                if (v.scrollable) {
                  message += `\nPosition: ${v.currentPosition}/${v.maxScroll}`;
                  message += `\nCan scroll up: ${v.canScrollUp}`;
                  message += `\nCan scroll down: ${v.canScrollDown}`;
                }
              } else {
                const h = scrollInfo.horizontal;
                message = `Horizontal scrolling: ${h.scrollable ? 'Available' : 'Not available'}`;
                if (h.scrollable) {
                  message += `\nPosition: ${h.currentPosition}/${h.maxScroll}`;
                  message += `\nCan scroll left: ${h.canScrollLeft}`;
                  message += `\nCan scroll right: ${h.canScrollRight}`;
                }
              }
  
              return {
                content: [
                  {
                    type: 'text',
                    text: message
                  }
                ]
              };
            }