toolsets

Documentation

Index

• func FormatJSONResponse(data interface{}) (string, error)
• func FormatListResponse(items interface{}, itemType string) (string, error)
• func GetBoolArgument(args map[string]interface{}, key string, required bool) (bool, error)
• func GetIntArgument(args map[string]interface{}, key string, required bool) (int, error)
• func GetStringArgument(args map[string]interface{}, key string, required bool) (string, error)
• func GetStringSliceArgument(args map[string]interface{}, key string, required bool) ([]string, error)
• type BaseToolset
  • func NewBaseToolset(name, description string, client JamfProClient, logger *zap.Logger) *BaseToolset
  • func (b *BaseToolset) AddTool(tool mcp.Tool)
  • func (b *BaseToolset) GetClient() JamfProClient
  • func (b *BaseToolset) GetDescription() string
  • func (b *BaseToolset) GetLogger() *zap.Logger
  • func (b *BaseToolset) GetName() string
  • func (b *BaseToolset) GetTools() []mcp.Tool
• type ComputerInventoryToolset
  • func NewComputerInventoryToolset(client JamfProClient, logger *zap.Logger) *ComputerInventoryToolset
  • func (c *ComputerInventoryToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)
• type ComputersToolset
  • func NewComputersToolset(client JamfProClient, logger *zap.Logger) *ComputersToolset
  • func (c *ComputersToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)
  • func (c *ComputersToolset) GetComputerTemplate() *jamfpro.ResponseComputer
• type Factory
  • func NewFactory(client JamfProClient, logger *zap.Logger) *Factory
  • func (f *Factory) CreateToolset(name string) (Toolset, error)
• type JamfProClient
• type MobileDevicesToolset
  • func NewMobileDevicesToolset(client JamfProClient, logger *zap.Logger) *MobileDevicesToolset
  • func (m *MobileDevicesToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)
  • func (m *MobileDevicesToolset) GetMobileDeviceTemplate() *jamfpro.ResourceMobileDevice
• type MockJamfProClient
• type PoliciesToolset
  • func NewPoliciesToolset(client JamfProClient, logger *zap.Logger) *PoliciesToolset
  • func (p *PoliciesToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)
• type ScriptsToolset
  • func NewScriptsToolset(client JamfProClient, logger *zap.Logger) *ScriptsToolset
  • func (s *ScriptsToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)
  • func (s *ScriptsToolset) GetScriptTemplate() *jamfpro.ResourceScript
• type Toolset

Functions

func FormatJSONResponse

func FormatJSONResponse(data interface{}) (string, error)

FormatJSONResponse formats a response as pretty-printed JSON

func FormatListResponse

func FormatListResponse(items interface{}, itemType string) (string, error)

FormatListResponse formats a list response with count information - FIXED: Better type handling

func GetBoolArgument

func GetBoolArgument(args map[string]interface{}, key string, required bool) (bool, error)

GetBoolArgument safely gets a boolean argument

func GetIntArgument

func GetIntArgument(args map[string]interface{}, key string, required bool) (int, error)

GetIntArgument safely gets an integer argument

func GetStringArgument

func GetStringArgument(args map[string]interface{}, key string, required bool) (string, error)

GetStringArgument safely gets a string argument

func GetStringSliceArgument

func GetStringSliceArgument(args map[string]interface{}, key string, required bool) ([]string, error)

GetStringSliceArgument safely gets a string slice argument

Types

type BaseToolset

type BaseToolset struct {
	// contains filtered or unexported fields
}

BaseToolset provides common functionality for all toolsets

func NewBaseToolset

func NewBaseToolset(name, description string, client JamfProClient, logger *zap.Logger) *BaseToolset

NewBaseToolset creates a new base toolset

func (*BaseToolset) AddTool

func (b *BaseToolset) AddTool(tool mcp.Tool)

AddTool adds a tool to the toolset

func (*BaseToolset) GetClient

func (b *BaseToolset) GetClient() JamfProClient

GetClient returns the Jamf Pro client

func (*BaseToolset) GetDescription

func (b *BaseToolset) GetDescription() string

GetDescription returns the description of the toolset

func (*BaseToolset) GetLogger

func (b *BaseToolset) GetLogger() *zap.Logger

GetLogger returns the logger

func (*BaseToolset) GetName

func (b *BaseToolset) GetName() string

GetName returns the name of the toolset

func (*BaseToolset) GetTools

func (b *BaseToolset) GetTools() []mcp.Tool

GetTools returns the list of tools

type ComputerInventoryToolset

type ComputerInventoryToolset struct {
	*BaseToolset
}

ComputerInventoryToolset handles computer inventory operations using Jamf Pro API

func NewComputerInventoryToolset

func NewComputerInventoryToolset(client JamfProClient, logger *zap.Logger) *ComputerInventoryToolset

NewComputerInventoryToolset creates a new computer inventory toolset

func (*ComputerInventoryToolset) ExecuteTool

func (c *ComputerInventoryToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)

ExecuteTool executes a computer inventory-related tool

type ComputersToolset

type ComputersToolset struct {
	*BaseToolset
}

ComputersToolset handles computer-related operations using Jamf Pro Classic API

func NewComputersToolset

func NewComputersToolset(client JamfProClient, logger *zap.Logger) *ComputersToolset

NewComputersToolset creates a new computers toolset

func (*ComputersToolset) ExecuteTool

func (c *ComputersToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)

ExecuteTool executes a computer-related tool

func (*ComputersToolset) GetComputerTemplate

func (c *ComputersToolset) GetComputerTemplate() *jamfpro.ResponseComputer

GetComputerTemplate returns an example template of a computer resource

type Factory

type Factory struct {
	// contains filtered or unexported fields
}

Factory creates toolsets

func NewFactory

func NewFactory(client JamfProClient, logger *zap.Logger) *Factory

NewFactory creates a new toolset factory

func (*Factory) CreateToolset

func (f *Factory) CreateToolset(name string) (Toolset, error)

CreateToolset creates a toolset by name

type JamfProClient

type JamfProClient interface {
	// Common methods
	GetJamfProInformation() (*jamfpro.ResponseJamfProInformation, error)

	// Computer methods (Classic API)
	GetComputers() (*jamfpro.ResponseComputersList, error)
	GetComputerByID(id string) (*jamfpro.ResponseComputer, error)
	GetComputerByName(name string) (*jamfpro.ResponseComputer, error)
	GetComputerGroups() (*jamfpro.ResponseComputerGroupsList, error)
	GetComputerGroupByID(id string) (*jamfpro.ResourceComputerGroup, error)
	CreateComputer(computer jamfpro.ResponseComputer) (*jamfpro.ResponseComputer, error)
	UpdateComputerByID(id string, computer jamfpro.ResponseComputer) (*jamfpro.ResponseComputer, error)
	UpdateComputerByName(name string, computer jamfpro.ResponseComputer) (*jamfpro.ResponseComputer, error)
	DeleteComputerByID(id string) error
	DeleteComputerByName(name string) error

	// Computer Inventory methods (Pro API)
	GetComputersInventory(params url.Values) (*jamfpro.ResponseComputerInventoryList, error)
	GetComputerInventoryByID(id string) (*jamfpro.ResourceComputerInventory, error)
	GetComputerInventoryByName(name string) (*jamfpro.ResourceComputerInventory, error)
	UpdateComputerInventoryByID(id string, inventory *jamfpro.ResourceComputerInventory) (*jamfpro.ResourceComputerInventory, error)
	DeleteComputerInventoryByID(id string) error

	// FileVault methods
	GetComputersFileVaultInventory(params url.Values) (*jamfpro.FileVaultInventoryList, error)
	GetComputerFileVaultInventoryByID(id string) (*jamfpro.FileVaultInventory, error)
	GetComputerRecoveryLockPasswordByID(id string) (*jamfpro.ResponseRecoveryLockPassword, error)

	// Device management methods
	RemoveComputerMDMProfile(id string) (*jamfpro.ResponseRemoveMDMProfile, error)
	EraseComputerByID(id string, request jamfpro.RequestEraseDeviceComputer) error

	// Attachment methods
	UploadAttachmentAndAssignToComputerByID(computerID string, filePaths []string) (*jamfpro.ResponseUploadAttachment, error)
	DeleteAttachmentByIDAndComputerID(computerID, attachmentID string) error

	// Mobile Device methods (Classic API)
	GetMobileDevices() (*jamfpro.ResponseMobileDeviceList, error)
	GetMobileDeviceByID(id string) (*jamfpro.ResourceMobileDevice, error)
	GetMobileDeviceByName(name string) (*jamfpro.ResourceMobileDevice, error)
	GetMobileDeviceGroups() (*jamfpro.ResponseMobileDeviceGroupsList, error)
	GetMobileDeviceGroupByID(id string) (*jamfpro.ResourceMobileDeviceGroup, error)
	GetMobileDeviceApplications() (*jamfpro.ResponseMobileDeviceApplicationsList, error)
	GetMobileDeviceConfigurationProfiles() (*jamfpro.ResponseMobileDeviceConfigurationProfilesList, error)
	CreateMobileDevice(device *jamfpro.ResourceMobileDevice) (*jamfpro.ResourceMobileDevice, error)
	UpdateMobileDeviceByID(id string, device *jamfpro.ResourceMobileDevice) (*jamfpro.ResourceMobileDevice, error)
	DeleteMobileDeviceByID(id string) error

	// Policies methods (Classic API) - FIXED: Corrected return types
	GetPolicies() (*jamfpro.ResponsePoliciesList, error)
	GetPolicyByID(id string) (*jamfpro.ResourcePolicy, error)
	GetPolicyByName(name string) (*jamfpro.ResourcePolicy, error)
	GetPolicyByCategory(category string) (*jamfpro.ResponsePoliciesList, error)
	GetPoliciesByType(createdBy string) (*jamfpro.ResponsePoliciesList, error)
	CreatePolicy(policy *jamfpro.ResourcePolicy) (*jamfpro.ResponsePolicyCreateAndUpdate, error)
	UpdatePolicyByID(id string, policy *jamfpro.ResourcePolicy) (*jamfpro.ResponsePolicyCreateAndUpdate, error)
	UpdatePolicyByName(name string, policy *jamfpro.ResourcePolicy) (*jamfpro.ResponsePolicyCreateAndUpdate, error)
	DeletePolicyByID(id string) error
	DeletePolicyByName(name string) error

	// Scripts methods (Pro API)
	GetScripts(params url.Values) (*jamfpro.ResponseScriptsList, error)
	GetScriptByID(id string) (*jamfpro.ResourceScript, error)
	GetScriptByName(name string) (*jamfpro.ResourceScript, error)
	CreateScript(script *jamfpro.ResourceScript) (*jamfpro.ResponseScriptCreate, error)
	UpdateScriptByID(id string, script *jamfpro.ResourceScript) (*jamfpro.ResourceScript, error)
	UpdateScriptByName(name string, script *jamfpro.ResourceScript) (*jamfpro.ResourceScript, error)
	DeleteScriptByID(id string) error
	DeleteScriptByName(name string) error
}

JamfProClient defines the interface for Jamf Pro API client This allows for dependency injection and easier testing

type MobileDevicesToolset

type MobileDevicesToolset struct {
	*BaseToolset
}

MobileDevicesToolset handles mobile device-related operations

func NewMobileDevicesToolset

func NewMobileDevicesToolset(client JamfProClient, logger *zap.Logger) *MobileDevicesToolset

NewMobileDevicesToolset creates a new mobile devices toolset

func (*MobileDevicesToolset) ExecuteTool

func (m *MobileDevicesToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)

func (*MobileDevicesToolset) GetMobileDeviceTemplate

func (m *MobileDevicesToolset) GetMobileDeviceTemplate() *jamfpro.ResourceMobileDevice

GetMobileDeviceTemplate returns an example template of a mobile device resource

type MockJamfProClient

type MockJamfProClient struct {
	mock.Mock
	*jamfpro.Client // Embed the real client to satisfy interface requirements
}

MockJamfProClient implements the jamfpro.Client interface for testing

type PoliciesToolset

type PoliciesToolset struct {
	*BaseToolset
}

PoliciesToolset handles policy-related operations using Jamf Pro Classic API

func NewPoliciesToolset

func NewPoliciesToolset(client JamfProClient, logger *zap.Logger) *PoliciesToolset

NewPoliciesToolset creates a new policies toolset

func (*PoliciesToolset) ExecuteTool

func (p *PoliciesToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)

ExecuteTool executes a policy-related tool

type ScriptsToolset

type ScriptsToolset struct {
	*BaseToolset
}

ScriptsToolset handles script-related operations using Jamf Pro API

func NewScriptsToolset

func NewScriptsToolset(client JamfProClient, logger *zap.Logger) *ScriptsToolset

NewScriptsToolset creates a new scripts toolset

func (*ScriptsToolset) ExecuteTool

func (s *ScriptsToolset) ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)

ExecuteTool executes a script-related tool

func (*ScriptsToolset) GetScriptTemplate

func (s *ScriptsToolset) GetScriptTemplate() *jamfpro.ResourceScript

GetScriptTemplate returns an example template of a script resource

type Toolset

type Toolset interface {
	// GetName returns the name of the toolset
	GetName() string

	// GetDescription returns the description of the toolset
	GetDescription() string

	// GetTools returns the list of tools provided by this toolset
	GetTools() []mcp.Tool

	// ExecuteTool executes a specific tool with the given arguments
	ExecuteTool(ctx context.Context, toolName string, arguments map[string]interface{}) (string, error)
}

Toolset represents a collection of related tools