Skip to main content
Glama
concavegit

App Store Connect MCP Server

by concavegit

list_app_store_versions

Retrieve all App Store versions for a specific application, with options to filter by platform, version string, or release status.

Instructions

Get all app store versions for a specific app

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
appIdYesThe ID of the app
limitNoMaximum number of versions to return (default: 100)
filterNoOptional filters for app store versions

Implementation Reference

  • The handler function that executes the tool logic: validates inputs, constructs API parameters with filters, and calls the AppStoreConnectClient to fetch app store versions.
    async listAppStoreVersions(args: {
      appId: string;
      limit?: number;
      filter?: {
        platform?: string;
        versionString?: string;
        appStoreState?: string;
      };
    }): Promise<ListAppStoreVersionsResponse> {
      const { appId, limit = 100, filter } = args;
      
      validateRequired(args, ['appId']);
      
      const params: Record<string, any> = {
        limit: sanitizeLimit(limit),
        'filter[app]': appId
      };
      
      if (filter?.platform) {
        params['filter[platform]'] = filter.platform;
      }
      
      if (filter?.versionString) {
        params['filter[versionString]'] = filter.versionString;
      }
      
      if (filter?.appStoreState) {
        params['filter[appStoreState]'] = filter.appStoreState;
      }
      
      return this.client.get<ListAppStoreVersionsResponse>(
        '/appStoreVersions',
        params
      );
    }
  • The MCP tool schema definition for 'list_app_store_versions', including name, description, and detailed input schema with properties, enums, and requirements.
      name: "list_app_store_versions",
      description: "Get all app store versions for a specific app",
      inputSchema: {
        type: "object",
        properties: {
          appId: {
            type: "string",
            description: "The ID of the app"
          },
          limit: {
            type: "number",
            description: "Maximum number of versions to return (default: 100)",
            minimum: 1,
            maximum: 200
          },
          filter: {
            type: "object",
            properties: {
              platform: {
                type: "string",
                description: "Filter by platform (IOS, MAC_OS, TV_OS)",
                enum: ["IOS", "MAC_OS", "TV_OS"]
              },
              versionString: {
                type: "string",
                description: "Filter by version string (e.g., '1.0.0')"
              },
              appStoreState: {
                type: "string",
                description: "Filter by app store state",
                enum: [
                  "DEVELOPER_REMOVED_FROM_SALE",
                  "DEVELOPER_REJECTED", 
                  "IN_REVIEW",
                  "INVALID_BINARY",
                  "METADATA_REJECTED",
                  "PENDING_APPLE_RELEASE",
                  "PENDING_CONTRACT",
                  "PENDING_DEVELOPER_RELEASE",
                  "PREPARE_FOR_SUBMISSION",
                  "PREORDER_READY_FOR_SALE",
                  "PROCESSING_FOR_APP_STORE",
                  "READY_FOR_SALE",
                  "REJECTED",
                  "REMOVED_FROM_SALE",
                  "WAITING_FOR_EXPORT_COMPLIANCE",
                  "WAITING_FOR_REVIEW",
                  "REPLACED_WITH_NEW_VERSION"
                ]
              }
            },
            description: "Optional filters for app store versions"
          }
        },
        required: ["appId"]
      }
    },
  • src/index.ts:1351-1353 (registration)
    The registration of the tool handler in the MCP CallToolRequestSchema switch statement, mapping the tool name to the LocalizationHandlers.listAppStoreVersions method.
    case "list_app_store_versions":
      return { toolResult: await this.localizationHandlers.listAppStoreVersions(args as any) };
  • The TypeScript interface defining the expected response structure for ListAppStoreVersionsResponse.
    export interface ListAppStoreVersionsResponse {
      data: AppStoreVersion[];
      links?: {
        self: string;
        next?: string;
      };
      meta?: {
        paging: {
          total: number;
          limit: number;
        };
      };
    }
  • src/index.ts:87-1288 (registration)
    The buildToolsList() method that constructs and returns the full list of available MCP tools, including 'list_app_store_versions'.
    private buildToolsList() {
      const baseTools = [
          // App Management Tools
          {
            name: "list_apps",
            description: "Get a list of all apps in App Store Connect",
            inputSchema: {
              type: "object",
              properties: {
                limit: {
                  type: "number",
                  description: "Maximum number of apps to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                }
              }
            }
          },
          {
            name: "get_app_info",
            description: "Get detailed information about a specific app",
            inputSchema: {
              type: "object", 
              properties: {
                appId: {
                  type: "string",
                  description: "The ID of the app to get information for"
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: [
                      "appClips", "appInfos", "appStoreVersions", "availableTerritories",
                      "betaAppReviewDetail", "betaGroups", "betaLicenseAgreement", "builds",
                      "endUserLicenseAgreement", "gameCenterEnabledVersions", "inAppPurchases",
                      "preOrder", "prices", "reviewSubmissions"
                    ]
                  },
                  description: "Optional relationships to include in the response"
                }
              },
              required: ["appId"]
            }
          },
    
          // Beta Testing Tools
          {
            name: "list_beta_groups",
            description: "Get a list of all beta groups (internal and external)",
            inputSchema: {
              type: "object",
              properties: {
                limit: {
                  type: "number",
                  description: "Maximum number of groups to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                }
              }
            }
          },
          {
            name: "list_group_testers",
            description: "Get a list of all testers in a specific beta group",
            inputSchema: {
              type: "object",
              properties: {
                groupId: {
                  type: "string",
                  description: "The ID of the beta group"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of testers to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                }
              },
              required: ["groupId"]
            }
          },
          {
            name: "add_tester_to_group",
            description: "Add a new tester to a beta group",
            inputSchema: {
              type: "object",
              properties: {
                groupId: {
                  type: "string",
                  description: "The ID of the beta group"
                },
                email: {
                  type: "string",
                  description: "Email address of the tester"
                },
                firstName: {
                  type: "string",
                  description: "First name of the tester"
                },
                lastName: {
                  type: "string",
                  description: "Last name of the tester"
                }
              },
              required: ["groupId", "email", "firstName", "lastName"]
            }
          },
          {
            name: "remove_tester_from_group",
            description: "Remove a tester from a beta group",
            inputSchema: {
              type: "object",
              properties: {
                groupId: {
                  type: "string",
                  description: "The ID of the beta group"
                },
                testerId: {
                  type: "string",
                  description: "The ID of the beta tester"
                }
              },
              required: ["groupId", "testerId"]
            }
          },
          {
            name: "list_beta_feedback_screenshots",
            description: "List all beta feedback screenshot submissions for an app. This includes feedback with screenshots, device information, and tester comments. You can identify the app using either appId or bundleId.",
            inputSchema: {
              type: "object",
              properties: {
                appId: {
                  type: "string",
                  description: "The ID of the app to get feedback for (e.g., '6747745091')"
                },
                bundleId: {
                  type: "string",
                  description: "The bundle ID of the app (e.g., 'com.example.app'). Can be used instead of appId."
                },
                buildId: {
                  type: "string",
                  description: "Filter by specific build ID (optional)"
                },
                devicePlatform: {
                  type: "string",
                  enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"],
                  description: "Filter by device platform (optional)"
                },
                appPlatform: {
                  type: "string",
                  enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"],
                  description: "Filter by app platform (optional)"
                },
                deviceModel: {
                  type: "string",
                  description: "Filter by device model (e.g., 'iPhone15_2') (optional)"
                },
                osVersion: {
                  type: "string",
                  description: "Filter by OS version (e.g., '18.4.1') (optional)"
                },
                testerId: {
                  type: "string",
                  description: "Filter by specific tester ID (optional)"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of feedback items to return (default: 50, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  enum: ["createdDate", "-createdDate"],
                  description: "Sort order for results (default: -createdDate for newest first)"
                },
                includeBuilds: {
                  type: "boolean",
                  description: "Include build information in response (optional)",
                  default: false
                },
                includeTesters: {
                  type: "boolean",
                  description: "Include tester information in response (optional)",
                  default: false
                }
              },
              required: []
            }
          },
          {
            name: "get_beta_feedback_screenshot",
            description: "Get detailed information about a specific beta feedback screenshot submission. By default, downloads and returns the screenshot image.",
            inputSchema: {
              type: "object",
              properties: {
                feedbackId: {
                  type: "string",
                  description: "The ID of the beta feedback screenshot submission"
                },
                includeBuilds: {
                  type: "boolean",
                  description: "Include build information in response (optional)",
                  default: false
                },
                includeTesters: {
                  type: "boolean",
                  description: "Include tester information in response (optional)",
                  default: false
                },
                downloadScreenshot: {
                  type: "boolean",
                  description: "Download and return the screenshot as an image (default: true)",
                  default: true
                }
              },
              required: ["feedbackId"]
            }
          },
          
          // App Store Version Localization Tools
          {
            name: "create_app_store_version",
            description: "Create a new app store version for an app",
            inputSchema: {
              type: "object",
              properties: {
                appId: {
                  type: "string",
                  description: "The ID of the app"
                },
                platform: {
                  type: "string",
                  description: "The platform for this version",
                  enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"]
                },
                versionString: {
                  type: "string",
                  description: "Version string in format X.Y or X.Y.Z (e.g., '1.0' or '1.0.0')"
                },
                copyright: {
                  type: "string",
                  description: "Copyright text for this version (optional)"
                },
                releaseType: {
                  type: "string",
                  description: "How the app should be released",
                  enum: ["MANUAL", "AFTER_APPROVAL", "SCHEDULED"]
                },
                earliestReleaseDate: {
                  type: "string",
                  description: "Earliest release date in ISO 8601 format (required when releaseType is SCHEDULED)"
                },
                buildId: {
                  type: "string",
                  description: "ID of the build to associate with this version (optional)"
                }
              },
              required: ["appId", "platform", "versionString"]
            }
          },
          {
            name: "list_app_store_versions",
            description: "Get all app store versions for a specific app",
            inputSchema: {
              type: "object",
              properties: {
                appId: {
                  type: "string",
                  description: "The ID of the app"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of versions to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                },
                filter: {
                  type: "object",
                  properties: {
                    platform: {
                      type: "string",
                      description: "Filter by platform (IOS, MAC_OS, TV_OS)",
                      enum: ["IOS", "MAC_OS", "TV_OS"]
                    },
                    versionString: {
                      type: "string",
                      description: "Filter by version string (e.g., '1.0.0')"
                    },
                    appStoreState: {
                      type: "string",
                      description: "Filter by app store state",
                      enum: [
                        "DEVELOPER_REMOVED_FROM_SALE",
                        "DEVELOPER_REJECTED", 
                        "IN_REVIEW",
                        "INVALID_BINARY",
                        "METADATA_REJECTED",
                        "PENDING_APPLE_RELEASE",
                        "PENDING_CONTRACT",
                        "PENDING_DEVELOPER_RELEASE",
                        "PREPARE_FOR_SUBMISSION",
                        "PREORDER_READY_FOR_SALE",
                        "PROCESSING_FOR_APP_STORE",
                        "READY_FOR_SALE",
                        "REJECTED",
                        "REMOVED_FROM_SALE",
                        "WAITING_FOR_EXPORT_COMPLIANCE",
                        "WAITING_FOR_REVIEW",
                        "REPLACED_WITH_NEW_VERSION"
                      ]
                    }
                  },
                  description: "Optional filters for app store versions"
                }
              },
              required: ["appId"]
            }
          },
          {
            name: "list_app_store_version_localizations",
            description: "Get all localizations for a specific app store version",
            inputSchema: {
              type: "object",
              properties: {
                appStoreVersionId: {
                  type: "string",
                  description: "The ID of the app store version"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of localizations to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                }
              },
              required: ["appStoreVersionId"]
            }
          },
          {
            name: "get_app_store_version_localization",
            description: "Get detailed information about a specific app store version localization",
            inputSchema: {
              type: "object",
              properties: {
                localizationId: {
                  type: "string",
                  description: "The ID of the app store version localization"
                }
              },
              required: ["localizationId"]
            }
          },
          {
            name: "update_app_store_version_localization",
            description: "Update a specific field in an app store version localization",
            inputSchema: {
              type: "object",
              properties: {
                localizationId: {
                  type: "string",
                  description: "The ID of the app store version localization to update"
                },
                field: {
                  type: "string",
                  enum: ["description", "keywords", "marketingUrl", "promotionalText", "supportUrl", "whatsNew"],
                  description: "The field to update"
                },
                value: {
                  type: "string",
                  description: "The new value for the field"
                }
              },
              required: ["localizationId", "field", "value"]
            }
          },
    
          // Bundle ID Tools
          {
            name: "create_bundle_id",
            description: "Register a new bundle ID for app development",
            inputSchema: {
              type: "object",
              properties: {
                identifier: {
                  type: "string",
                  description: "The bundle ID string (e.g., 'com.example.app')"
                },
                name: {
                  type: "string",
                  description: "A name for the bundle ID"
                },
                platform: {
                  type: "string",
                  enum: ["IOS", "MAC_OS", "UNIVERSAL"],
                  description: "The platform for this bundle ID"
                },
                seedId: {
                  type: "string",
                  description: "Your team's seed ID (optional)"
                }
              },
              required: ["identifier", "name", "platform"]
            }
          },
          {
            name: "list_bundle_ids",
            description: "Find and list bundle IDs that are registered to your team",
            inputSchema: {
              type: "object",
              properties: {
                limit: {
                  type: "number",
                  description: "Maximum number of bundle IDs to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: [
                    "name", "-name", "platform", "-platform", 
                    "identifier", "-identifier", "seedId", "-seedId", "id", "-id"
                  ]
                },
                filter: {
                  type: "object",
                  properties: {
                    identifier: { type: "string", description: "Filter by bundle identifier" },
                    name: { type: "string", description: "Filter by name" },
                    platform: { 
                      type: "string", 
                      description: "Filter by platform",
                      enum: ["IOS", "MAC_OS", "UNIVERSAL"]
                    },
                    seedId: { type: "string", description: "Filter by seed ID" }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["profiles", "bundleIdCapabilities", "app"]
                  },
                  description: "Related resources to include in the response"
                }
              }
            }
          },
          {
            name: "get_bundle_id_info",
            description: "Get detailed information about a specific bundle ID",
            inputSchema: {
              type: "object",
              properties: {
                bundleIdId: {
                  type: "string",
                  description: "The ID of the bundle ID to get information for"
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["profiles", "bundleIdCapabilities", "app"]
                  },
                  description: "Optional relationships to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    bundleIds: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["name", "platform", "identifier", "seedId"]
                      },
                      description: "Fields to include for the bundle ID"
                    }
                  },
                  description: "Specific fields to include in the response"
                }
              },
              required: ["bundleIdId"]
            }
          },
          {
            name: "enable_bundle_capability",
            description: "Enable a capability for a bundle ID",
            inputSchema: {
              type: "object",
              properties: {
                bundleIdId: {
                  type: "string",
                  description: "The ID of the bundle ID"
                },
                capabilityType: {
                  type: "string",
                  description: "The type of capability to enable",
                  enum: [
                    "ICLOUD", "IN_APP_PURCHASE", "GAME_CENTER", "PUSH_NOTIFICATIONS", "WALLET",
                    "INTER_APP_AUDIO", "MAPS", "ASSOCIATED_DOMAINS", "PERSONAL_VPN", "APP_GROUPS",
                    "HEALTHKIT", "HOMEKIT", "WIRELESS_ACCESSORY_CONFIGURATION", "APPLE_PAY",
                    "DATA_PROTECTION", "SIRIKIT", "NETWORK_EXTENSIONS", "MULTIPATH", "HOT_SPOT",
                    "NFC_TAG_READING", "CLASSKIT", "AUTOFILL_CREDENTIAL_PROVIDER", "ACCESS_WIFI_INFORMATION",
                    "NETWORK_CUSTOM_PROTOCOL", "COREMEDIA_HLS_LOW_LATENCY", "SYSTEM_EXTENSION_INSTALL",
                    "USER_MANAGEMENT", "APPLE_ID_AUTH"
                  ]
                },
                settings: {
                  type: "array",
                  description: "Optional capability settings",
                  items: {
                    type: "object",
                    properties: {
                      key: { type: "string", description: "The setting key" },
                      options: {
                        type: "array",
                        items: {
                          type: "object",
                          properties: {
                            key: { type: "string" },
                            enabled: { type: "boolean" }
                          }
                        }
                      }
                    }
                  }
                }
              },
              required: ["bundleIdId", "capabilityType"]
            }
          },
          {
            name: "disable_bundle_capability",
            description: "Disable a capability for a bundle ID",
            inputSchema: {
              type: "object",
              properties: {
                capabilityId: {
                  type: "string",
                  description: "The ID of the capability to disable"
                }
              },
              required: ["capabilityId"]
            }
          },
    
          // Device Management Tools
          {
            name: "list_devices",
            description: "Get a list of all devices registered to your team",
            inputSchema: {
              type: "object",
              properties: {
                limit: {
                  type: "number",
                  description: "Maximum number of devices to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: [
                    "name", "-name", "platform", "-platform", "status", "-status",
                    "udid", "-udid", "deviceClass", "-deviceClass", "model", "-model",
                    "addedDate", "-addedDate"
                  ]
                },
                filter: {
                  type: "object",
                  properties: {
                    name: { type: "string", description: "Filter by device name" },
                    platform: { 
                      type: "string", 
                      description: "Filter by platform",
                      enum: ["IOS", "MAC_OS"]
                    },
                    status: { 
                      type: "string", 
                      description: "Filter by status",
                      enum: ["ENABLED", "DISABLED"]
                    },
                    udid: { type: "string", description: "Filter by device UDID" },
                    deviceClass: { 
                      type: "string", 
                      description: "Filter by device class",
                      enum: ["APPLE_WATCH", "IPAD", "IPHONE", "IPOD", "APPLE_TV", "MAC"]
                    }
                  }
                },
                fields: {
                  type: "object",
                  properties: {
                    devices: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["name", "platform", "udid", "deviceClass", "status", "model", "addedDate"]
                      },
                      description: "Fields to include for each device"
                    }
                  }
                }
              }
            }
          },
    
          // User Management Tools
          {
            name: "list_users",
            description: "Get a list of all users registered on your App Store Connect team",
            inputSchema: {
              type: "object",
              properties: {
                limit: {
                  type: "number",
                  description: "Maximum number of users to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: ["username", "-username", "firstName", "-firstName", "lastName", "-lastName", "roles", "-roles"]
                },
                filter: {
                  type: "object",
                  properties: {
                    username: { type: "string", description: "Filter by username" },
                    roles: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: [
                          "ADMIN", "FINANCE", "TECHNICAL", "SALES", "MARKETING", "DEVELOPER",
                          "ACCOUNT_HOLDER", "READ_ONLY", "APP_MANAGER", "ACCESS_TO_REPORTS", "CUSTOMER_SUPPORT"
                        ]
                      },
                      description: "Filter by user roles"
                    },
                    visibleApps: {
                      type: "array",
                      items: { type: "string" },
                      description: "Filter by apps the user can see (app IDs)"
                    }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["visibleApps"]
                  },
                  description: "Related resources to include in the response"
                }
              }
            }
          },
    
          // Analytics & Reports Tools
          {
            name: "create_analytics_report_request",
            description: "Create a new analytics report request for an app",
            inputSchema: {
              type: "object",
              properties: {
                appId: {
                  type: "string",
                  description: "The ID of the app to generate analytics reports for"
                },
                accessType: {
                  type: "string",
                  enum: ["ONGOING", "ONE_TIME_SNAPSHOT"],
                  description: "Access type for the analytics report (ONGOING for daily data, ONE_TIME_SNAPSHOT for historical data)",
                  default: "ONE_TIME_SNAPSHOT"
                }
              },
              required: ["appId"]
            }
          },
          {
            name: "list_analytics_reports",
            description: "Get available analytics reports for a specific report request",
            inputSchema: {
              type: "object",
              properties: {
                reportRequestId: {
                  type: "string",
                  description: "The ID of the analytics report request"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of reports to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                },
                filter: {
                  type: "object",
                  properties: {
                    category: {
                      type: "string",
                      enum: ["APP_STORE_ENGAGEMENT", "APP_STORE_COMMERCE", "APP_USAGE", "FRAMEWORKS_USAGE", "PERFORMANCE"],
                      description: "Filter by report category"
                    }
                  }
                }
              },
              required: ["reportRequestId"]
            }
          },
          {
            name: "list_analytics_report_segments",
            description: "Get segments for a specific analytics report (contains download URLs)",
            inputSchema: {
              type: "object",
              properties: {
                reportId: {
                  type: "string",
                  description: "The ID of the analytics report"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of segments to return (default: 100)",
                  minimum: 1,
                  maximum: 200
                }
              },
              required: ["reportId"]
            }
          },
          {
            name: "download_analytics_report_segment",
            description: "Download data from an analytics report segment URL",
            inputSchema: {
              type: "object",
              properties: {
                segmentUrl: {
                  type: "string",
                  description: "The URL of the analytics report segment to download"
                }
              },
              required: ["segmentUrl"]
            }
          },
    
          // Xcode Development Tools
          {
            name: "list_schemes",
            description: "List all available schemes in an Xcode project or workspace",
            inputSchema: {
              type: "object",
              properties: {
                projectPath: {
                  type: "string",
                  description: "Path to the Xcode project (.xcodeproj) or workspace (.xcworkspace)"
                }
              },
              required: ["projectPath"]
            }
          },
    
          // Workflow Management Tools  
          {
            name: "list_workflows",
            description: "List all App Store Connect workflows (CI products) and their associated apps",
            inputSchema: {
              type: "object",
              properties: {
                limit: {
                  type: "number",
                  description: "Maximum number of workflows to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: ["name", "-name", "productType", "-productType"]
                },
                filter: {
                  type: "object",
                  properties: {
                    productType: {
                      type: "string",
                      description: "Filter by product type",
                      enum: ["IOS", "MAC_OS", "TV_OS", "VISION_OS"]
                    }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["app", "bundleId", "primaryRepositories"]
                  },
                  description: "Related resources to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    ciProducts: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["name", "productType"]
                      },
                      description: "Fields to include for each workflow"
                    }
                  }
                }
              }
            }
          },
    
          // Build Run Management Tools
          {
            name: "list_build_runs",
            description: "List build runs for a specific workflow/CI product, including git commit information",
            inputSchema: {
              type: "object",
              properties: {
                ciProductId: {
                  type: "string",
                  description: "The ID of the CI product (workflow) to list build runs for"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of build runs to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: ["number", "-number", "createdDate", "-createdDate", "startedDate", "-startedDate", "finishedDate", "-finishedDate"]
                },
                filter: {
                  type: "object",
                  properties: {
                    number: {
                      type: "number",
                      description: "Filter by build run number"
                    },
                    isPullRequestBuild: {
                      type: "boolean",
                      description: "Filter by whether it's a pull request build"
                    },
                    executionProgress: {
                      type: "string",
                      enum: ["PENDING", "RUNNING", "COMPLETE"],
                      description: "Filter by execution progress"
                    },
                    completionStatus: {
                      type: "string",
                      enum: ["SUCCEEDED", "FAILED", "ERRORED", "CANCELED", "SKIPPED"],
                      description: "Filter by completion status"
                    },
                    startReason: {
                      type: "string",
                      enum: ["MANUAL", "SCM_CHANGE", "PULL_REQUEST_UPDATE", "SCHEDULED"],
                      description: "Filter by start reason"
                    }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["builds", "workflow", "product", "sourceBranchOrTag", "destinationBranch", "pullRequest"]
                  },
                  description: "Related resources to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    ciBuildRuns: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["number", "createdDate", "startedDate", "finishedDate", "sourceCommit", "destinationCommit", "isPullRequestBuild", "issueCounts", "executionProgress", "completionStatus", "startReason", "cancelReason"]
                      },
                      description: "Fields to include for each build run"
                    }
                  }
                }
              },
              required: ["ciProductId"]
            }
          },
    
          // CI Build Actions Management
          {
            name: "list_ci_build_actions",
            description: "List build actions (analyze, build, test, archive) for a specific build run",
            inputSchema: {
              type: "object",
              properties: {
                buildRunId: {
                  type: "string",
                  description: "The ID of the build run to list actions for"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of build actions to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: ["name", "-name", "actionType", "-actionType", "startedDate", "-startedDate", "finishedDate", "-finishedDate"]
                },
                filter: {
                  type: "object",
                  properties: {
                    actionType: {
                      type: "string",
                      enum: ["ANALYZE", "BUILD", "TEST", "ARCHIVE"],
                      description: "Filter by action type"
                    },
                    executionProgress: {
                      type: "string",
                      enum: ["PENDING", "RUNNING", "COMPLETE"],
                      description: "Filter by execution progress"
                    },
                    completionStatus: {
                      type: "string",
                      enum: ["SUCCEEDED", "FAILED", "ERRORED", "CANCELED", "SKIPPED"],
                      description: "Filter by completion status"
                    }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["buildRun", "issues", "testResults"]
                  },
                  description: "Related resources to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    ciBuildActions: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["name", "actionType", "startedDate", "finishedDate", "issueCounts", "executionProgress", "completionStatus"]
                      },
                      description: "Fields to include for each build action"
                    }
                  }
                }
              },
              required: ["buildRunId"]
            }
          },
    
          {
            name: "get_ci_build_action",
            description: "Get detailed information about a specific build action",
            inputSchema: {
              type: "object",
              properties: {
                buildActionId: {
                  type: "string",
                  description: "The ID of the build action"
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["buildRun", "issues", "testResults"]
                  },
                  description: "Related resources to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    ciBuildActions: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["name", "actionType", "startedDate", "finishedDate", "issueCounts", "executionProgress", "completionStatus"]
                      },
                      description: "Fields to include for the build action"
                    }
                  }
                }
              },
              required: ["buildActionId"]
            }
          },
    
          // CI Issues Management
          {
            name: "list_ci_issues",
            description: "List issues and errors from a build run or build action",
            inputSchema: {
              type: "object",
              properties: {
                buildRunId: {
                  type: "string",
                  description: "The ID of the build run to list issues for (provide either buildRunId or buildActionId)"
                },
                buildActionId: {
                  type: "string",
                  description: "The ID of the build action to list issues for (provide either buildRunId or buildActionId)"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of issues to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: ["issueType", "-issueType", "category", "-category", "message", "-message"]
                },
                filter: {
                  type: "object",
                  properties: {
                    issueType: {
                      type: "string",
                      enum: ["ANALYZER_WARNING", "ERROR", "TEST_FAILURE", "WARNING"],
                      description: "Filter by issue type"
                    },
                    category: {
                      type: "string",
                      description: "Filter by issue category"
                    }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["buildAction", "buildRun"]
                  },
                  description: "Related resources to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    ciIssues: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["issueType", "message", "fileSource", "category"]
                      },
                      description: "Fields to include for each issue"
                    }
                  }
                }
              }
            }
          },
    
          // CI Test Results Management
          {
            name: "list_ci_test_results",
            description: "List test results from a build run or build action",
            inputSchema: {
              type: "object",
              properties: {
                buildRunId: {
                  type: "string",
                  description: "The ID of the build run to list test results for (provide either buildRunId or buildActionId)"
                },
                buildActionId: {
                  type: "string",
                  description: "The ID of the build action to list test results for (provide either buildRunId or buildActionId)"
                },
                limit: {
                  type: "number",
                  description: "Maximum number of test results to return (default: 100, max: 200)",
                  minimum: 1,
                  maximum: 200
                },
                sort: {
                  type: "string",
                  description: "Sort order for the results",
                  enum: ["className", "-className", "name", "-name", "status", "-status", "duration", "-duration"]
                },
                filter: {
                  type: "object",
                  properties: {
                    status: {
                      type: "string",
                      enum: ["SUCCESS", "FAILURE", "SKIPPED"],
                      description: "Filter by test status"
                    },
                    className: {
                      type: "string",
                      description: "Filter by test class name"
                    },
                    name: {
                      type: "string",
                      description: "Filter by test name"
                    }
                  }
                },
                include: {
                  type: "array",
                  items: {
                    type: "string",
                    enum: ["buildAction", "buildRun"]
                  },
                  description: "Related resources to include in the response"
                },
                fields: {
                  type: "object",
                  properties: {
                    ciTestResults: {
                      type: "array",
                      items: {
                        type: "string",
                        enum: ["className", "name", "status", "fileLocation", "failureMessage", "duration"]
                      },
                      description: "Fields to include for each test result"
                    }
                  }
                }
              }
            }
          }
      ];
    
      // Sales and Finance Report tools - only available if vendor number is configured
      const paymentReportTools = [
        {
          name: "download_sales_report",
          description: "Download sales and trends reports",
          inputSchema: {
            type: "object",
            properties: {
              vendorNumber: {
                type: "string",
                description: "Your vendor number from App Store Connect (optional if set as environment variable)",
                default: this.vendorNumber
              },
              reportType: {
                type: "string",
                enum: ["SALES"],
                description: "Type of report to download",
                default: "SALES"
              },
              reportSubType: {
                type: "string",
                enum: ["SUMMARY", "DETAILED"],
                description: "Sub-type of the report",
                default: "SUMMARY"
              },
              frequency: {
                type: "string",
                enum: ["DAILY", "WEEKLY", "MONTHLY", "YEARLY"],
                description: "Frequency of the report",
                default: "MONTHLY"
              },
              reportDate: {
                type: "string",
                description: "Report date in YYYY-MM format (e.g., '2024-01')"
              }
            },
            required: ["reportDate"]
          }
        },
        {
          name: "download_finance_report",
          description: "Download finance reports for a specific region",
          inputSchema: {
            type: "object",
            properties: {
              vendorNumber: {
                type: "string",
                description: "Your vendor number from App Store Connect (optional if set as environment variable)",
                default: this.vendorNumber
              },
              reportDate: {
                type: "string",
                description: "Report date in YYYY-MM format (e.g., '2024-01')"
              },
              regionCode: {
                type: "string",
                description: "Region code (e.g., 'Z1' for worldwide, 'WW' for Europe)"
              }
            },
            required: ["reportDate", "regionCode"]
          }
        }
      ];
    
      // Only include payment report tools if vendor number is configured
      if (this.vendorNumber) {
        return [...baseTools, ...paymentReportTools];
      }
    
      return baseTools;
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get all app store versions' but doesn't mention whether this is a read-only operation, if it requires authentication, how results are paginated (beyond the limit parameter), or what the output format looks like. For a list operation with no annotation coverage, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of it earns its place by clearly stating the tool's function, making it highly concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (3 parameters with nested objects) and lack of annotations or output schema, the description is incomplete. It doesn't address behavioral aspects like pagination, authentication needs, or error handling, which are crucial for an agent to use this tool effectively. The schema covers parameters well, but the description fails to provide necessary context beyond the basic purpose.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all parameters (appId, limit, filter). The description adds no additional meaning beyond implying filtering by app, which is already covered in the schema. This meets the baseline of 3 where the schema does the heavy lifting, but the description doesn't enhance parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get all') and resource ('app store versions for a specific app'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_app_info' or 'list_apps', which might also retrieve app-related information, so it doesn't fully distinguish itself from alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'get_app_info' or 'list_apps'. It lacks context about prerequisites, such as needing an app ID, or exclusions, such as not being suitable for retrieving single versions. This leaves the agent without clear usage direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

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/concavegit/app-store-connect-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server