get_plugins_with_problems

Instructions

Implementation Reference

• src/mcp_jenkins/server/plugin.py:36-46 (handler)

  MCP tool handler that returns plugins with problems, delegating to the Jenkins REST client method.

  @mcp.tool(tags={'read'})
  async def get_plugins_with_problems(ctx: Context) -> list[dict]:
      """Get all plugins with problems from Jenkins
  
      These are plugins that have issues such as missing dependencies,
      incompatible versions, core version mismatch, or other configuration problems.
  
      Returns:
          A list of plugins with problems
      """
      return jenkins(ctx).get_plugins_with_problems()

• src/mcp_jenkins/jenkins/rest_client.py:660-773 (schema)

  Core implementation that checks for plugin problems: incompatible core version, disabled plugins, missing dependencies (optional and required), and version mismatches.

  def get_plugins_with_problems(self) -> list[dict]:
      """Get a list of plugins that have dependency problems.
  
      Checks each plugin's dependencies against the installed plugins
      to identify missing dependencies or version mismatches.
  
      Returns:
          A list of plugins with dependency problems.
      """
      jenkins_version = self._get_jenkins_version()
      plugins = self.get_plugins(depth=2)
  
      installed = {p['shortName']: p for p in plugins}
  
      problems = []
      for plugin in plugins:
          short_name = plugin.get('shortName', '')
          version = plugin.get('version', '')
          required_core = plugin.get('requiredCoreVersion', '')
  
          if required_core and jenkins_version:
              if not self._is_core_compatible(jenkins_version, required_core):
                  problems.append(
                      {
                          'shortName': short_name,
                          'problem': 'incompatible_core_version',
                          'pluginVersion': version,
                          'requiredCoreVersion': required_core,
                          'jenkinsVersion': jenkins_version,
                          'severity': 'error',
                          'message': (
                              f'Plugin requires Jenkins {required_core}, but current version is {jenkins_version}'
                          ),
                      }
                  )
  
          if not plugin.get('enabled'):
              problems.append(
                  {
                      'shortName': short_name,
                      'problem': 'plugin_disabled',
                      'pluginVersion': version,
                      'severity': 'warning',
                      'message': 'Plugin is currently disabled',
                  }
              )
  
          deps = plugin.get('dependencies', [])
          for dep in deps:
              dep_name = dep.get('shortName', '')
              dep_version = dep.get('version', '')
              is_optional = dep.get('optional', False)
              is_bundled = dep.get('bundled', False)
  
              if dep_name not in installed:
                  if is_optional:
                      problems.append(
                          {
                              'shortName': short_name,
                              'problem': 'missing_optional_dependency',
                              'dependency': dep_name,
                              'requiredVersion': dep_version,
                              'severity': 'info',
                              'message': f'Missing optional dependency: {dep_name}',
                          }
                      )
                  elif not is_bundled:
                      problems.append(
                          {
                              'shortName': short_name,
                              'problem': 'missing_dependency',
                              'dependency': dep_name,
                              'requiredVersion': dep_version,
                              'severity': 'error',
                              'message': f'Missing required dependency: {dep_name}',
                          }
                      )
              else:
                  installed_ver = installed[dep_name].get('version', '')
                  if dep_version and installed_ver and installed_ver != dep_version:
                      if self._is_version_greater(installed_ver, dep_version):
                          continue
                      if is_optional:
                          problems.append(
                              {
                                  'shortName': short_name,
                                  'problem': 'version_mismatch_optional',
                                  'dependency': dep_name,
                                  'requiredVersion': dep_version,
                                  'installedVersion': installed_ver,
                                  'severity': 'info',
                                  'message': (
                                      f'Optional dependency {dep_name} version mismatch: '
                                      f'required {dep_version}, installed {installed_ver}'
                                  ),
                              }
                          )
                      else:
                          problems.append(
                              {
                                  'shortName': short_name,
                                  'problem': 'version_mismatch',
                                  'dependency': dep_name,
                                  'requiredVersion': dep_version,
                                  'installedVersion': installed_ver,
                                  'severity': 'error',
                                  'message': (
                                      f'Dependency {dep_name} version mismatch: '
                                      f'required {dep_version}, installed {installed_ver}'
                                  ),
                              }
                          )
  
      return problems

• src/mcp_jenkins/server/__init__.py:30-35 (registration)

  MCP server instance creation and plugin module import that registers the tool via @mcp.tool decorator.

  mcp = JenkinsMCP('mcp-jenkins', lifespan=lifespan)
  
  # Import tool modules to register them with the MCP server
  # This must happen after mcp is created so the @mcp.tool() decorators can reference it
  from mcp_jenkins.server import build, item, node, plugin, queue, view  # noqa: F401, E402

• src/mcp_jenkins/jenkins/rest_client.py:820-823 (helper)

  Helper method that retrieves the Jenkins core version from response headers.

  def _get_jenkins_version(self) -> str:
      """Get the Jenkins core version from response header."""
      response = self.request('GET', '', crumb=False)
      return response.headers.get('X-Jenkins', '')

• src/mcp_jenkins/jenkins/rest_client.py:825-836 (helper)

  Helper method that checks if the Jenkins core version is compatible with a plugin's required core version.

  def _is_core_compatible(self, jenkins_ver: str, required_ver: str) -> bool:
      """Check if Jenkins version is compatible with required core version."""
      if not isinstance(jenkins_ver, str) or not isinstance(required_ver, str):
          return True
  
      def normalize_version(v: str) -> tuple:
          parts = v.split('.')
          return tuple(int(p) if p.isdigit() else 0 for p in parts[:3])
  
      core = normalize_version(jenkins_ver)
      required = normalize_version(required_ver)
      return core >= required