{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-getsentry--xcodebuildmcp","slug":"getsentry--xcodebuildmcp","name":"XcodeBuildMCP","type":"mcp","url":"https://www.xcodebuildmcp.com","page_url":"https://unfragile.ai/getsentry--xcodebuildmcp","categories":["mcp-servers"],"tags":["mcp","mcp-server","model-context-protocol","model-context-protocol-servers","tag-production","xcode","xcodebuild"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-getsentry--xcodebuildmcp__cap_0","uri":"capability://tool.use.integration.dual.mode.tool.invocation.with.unified.implementation","name":"dual-mode tool invocation with unified implementation","description":"Exposes 77 tools across 15 workflows through both MCP JSON-RPC server mode (for AI agents) and CLI mode (for direct invocation), with a shared implementation layer in build/cli.js that ensures identical behavior regardless of interface. The tool registry uses manifest-driven discovery to map workflow names to executable implementations, eliminating code duplication between modes.","intents":["I want to use the same Xcode tools from both Claude/Cursor agents and my CI/CD pipeline without maintaining separate implementations","I need to expose iOS build capabilities to AI agents while keeping CLI access for human developers","I want to standardize tool behavior across MCP and command-line interfaces"],"best_for":["teams integrating AI agents into iOS/macOS development workflows","CI/CD systems that need both programmatic and agent-based access to build tools","developers building hybrid human-AI development environments"],"limitations":["Dual-mode design adds complexity to tool development — changes must be validated in both CLI and MCP contexts","Context window optimization defaults to simulator-only tools; enabling all 77 tools may exceed agent token budgets","TypeScript-only implementation — no native Python or Go bindings for alternative MCP clients"],"requires":["Node.js 18+ (for TypeScript execution)","Xcode 14+ (for xcodebuild and simulator management)","macOS 12+ (for iOS simulator and device support)","MCP client (Cursor, Claude, VS Code with MCP extension) for agent mode"],"input_types":["workflow name (string)","tool name (string)","tool-specific parameters (JSON schema validated)"],"output_types":["structured JSON (MCP mode)","formatted text/ANSI (CLI mode)","build logs and diagnostics"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_1","uri":"capability://automation.workflow.ios.simulator.lifecycle.management.with.workflow.automation","name":"ios simulator lifecycle management with workflow automation","description":"Provides comprehensive simulator control through a dedicated Simulator Workflows module that handles device creation, booting, shutdown, and state management. The system tracks simulator state across sessions using session management tools and integrates with the background daemon to maintain long-running simulator instances without blocking agent execution.","intents":["I need to programmatically boot an iOS simulator and run tests without manual Xcode interaction","I want to manage multiple simulator instances and switch between them in CI/CD pipelines","I need to reset simulator state between test runs to ensure clean environments"],"best_for":["iOS developers automating simulator-based testing in CI/CD","AI agents building and testing iOS apps with minimal human intervention","teams running parallel simulator instances for multi-device testing"],"limitations":["Simulator management is resource-intensive — running multiple simulators simultaneously requires 8GB+ RAM and can exceed agent context windows","Simulator state persistence requires explicit session management; transient agents without session support may lose simulator context between invocations","iOS simulator availability is macOS-only; no support for Android or cloud-based simulators"],"requires":["Xcode 14+ with iOS SDK","macOS 12+ with virtualization support","minimum 4GB free RAM per simulator instance","simulator workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["simulator device type (string: iPhone 15, iPad Pro, etc.)","iOS version (string: 17.0, 18.0, etc.)","session identifier (string, optional)"],"output_types":["simulator UDID (string)","boot status (JSON: {status, timestamp, device_info})","device state logs (text)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_10","uri":"capability://automation.workflow.ui.automation.and.accessibility.testing.with.xcuitest.integration","name":"ui automation and accessibility testing with xcuitest integration","description":"Provides tools to write and execute UI automation tests using XCUITest framework, with integration for accessibility testing and screen recording. The system captures test output, screenshots, and accessibility audit results in structured format.","intents":["I want to run UI automation tests and get structured results showing which UI interactions failed","I need to perform accessibility audits on my iOS app and get a report of accessibility issues","I want to record screen video during UI tests for debugging failed interactions"],"best_for":["teams automating UI testing for iOS apps","developers ensuring accessibility compliance","AI agents that need to understand UI test failures and suggest fixes"],"limitations":["XCUITest execution is slow (5-30 seconds per test) due to simulator overhead; not suitable for rapid iteration","UI test flakiness is common due to timing issues and simulator variability; tests may fail intermittently","Screen recording and accessibility audits add significant overhead; can increase test execution time by 50%+"],"requires":["Xcode 14+ with XCUITest framework","iOS simulator or physical device","UI test targets defined in Xcode project"],"input_types":["test scheme (string)","enable_recording (boolean, optional)","enable_accessibility_audit (boolean, optional)"],"output_types":["test results (JSON: {total: int, passed: int, failed: int, tests: [{name, status, duration}]})","accessibility report (JSON: {issues: [{element, issue_type, severity, description}]})","screen recording path (string, optional)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_11","uri":"capability://data.processing.analysis.code.coverage.analysis.and.trend.tracking","name":"code coverage analysis and trend tracking","description":"Generates code coverage reports from test execution, parses coverage data (line, branch, function coverage), and tracks coverage trends across builds. The system integrates with coverage tools like llvm-cov and provides JSON output with per-file and per-function coverage metrics.","intents":["I want to measure code coverage for my iOS app and identify untested code","I need to enforce minimum coverage thresholds and fail builds that don't meet them","I want to track coverage trends over time and identify regressions"],"best_for":["teams enforcing code coverage standards","CI/CD systems that need to gate builds on coverage metrics","developers identifying untested code paths for improvement"],"limitations":["Coverage measurement requires instrumenting binaries, adding 20-30% overhead to test execution","Coverage data is only available for code compiled with coverage instrumentation; external dependencies may not have coverage data","Coverage metrics can be misleading (high coverage doesn't guarantee code quality); requires manual interpretation"],"requires":["Xcode 14+ with coverage support","test targets with coverage enabled","llvm-cov or similar coverage tool installed"],"input_types":["scheme name (string)","minimum_coverage_threshold (float, optional; default: 0.0)"],"output_types":["coverage report (JSON: {overall_coverage: float, files: [{path, coverage_percent, lines_covered, lines_total}]})","coverage summary (JSON: {line_coverage: float, branch_coverage: float, function_coverage: float})","threshold check (JSON: {passed: boolean, coverage: float, threshold: float})"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_12","uri":"capability://tool.use.integration.xcode.ide.integration.and.workspace.navigation","name":"xcode ide integration and workspace navigation","description":"Provides tools to open projects in Xcode IDE, navigate to specific files and line numbers, and trigger Xcode actions (build, test, run) from the command line. The system uses AppleScript and Xcode's command-line tools to control the IDE programmatically.","intents":["I want to open a file in Xcode at a specific line number for manual inspection","I need to trigger Xcode builds and tests from the command line while keeping the IDE open","I want to navigate to compilation errors in Xcode for interactive debugging"],"best_for":["developers who prefer Xcode IDE for interactive development","hybrid workflows that combine automated tools with manual IDE interaction","teams that need to switch between CLI and IDE workflows seamlessly"],"limitations":["IDE integration requires AppleScript which is fragile and version-dependent; may break with Xcode updates","AppleScript execution is slow (1-5 seconds per command) due to IPC overhead","IDE state is not queryable; cannot determine if a file is already open or if IDE is in a specific state"],"requires":["Xcode 14+ installed and in standard location","AppleScript support enabled (default on macOS)","IDE integration workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["file path (string)","line number (integer, optional)","action (string: open, build, test, run)"],"output_types":["action result (JSON: {status, message})"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_13","uri":"capability://code.generation.editing.project.scaffolding.and.template.generation","name":"project scaffolding and template generation","description":"Provides tools to generate new iOS and macOS projects from templates, with customizable project structure, dependencies, and build configurations. The system uses manifest-based templates to define project structure and automatically generates boilerplate code.","intents":["I want to generate a new iOS project with a specific architecture (MVVM, Clean, etc.)","I need to scaffold a new macOS app with standard dependencies and build configuration","I want to create a new test target with boilerplate test code"],"best_for":["developers starting new iOS/macOS projects","AI agents that need to create new projects as part of larger workflows","teams standardizing project structure across multiple projects"],"limitations":["Template-based generation is rigid; complex project structures may require manual customization","Generated code is boilerplate and may not follow team-specific conventions","Template maintenance is required; templates must be updated for new Xcode versions and Swift versions"],"requires":["Xcode 14+ with project templates","write access to project directory","project scaffolding workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["project name (string)","project type (string: ios-app, macos-app, framework, etc.)","template name (string, optional)","dependencies (array of strings, optional)"],"output_types":["project path (string)","project structure (JSON: {files: [], directories: []})","generation status (JSON: {status, message})"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_14","uri":"capability://tool.use.integration.swift.package.manager.integration.and.dependency.management","name":"swift package manager integration and dependency management","description":"Provides tools to manage Swift package dependencies, resolve package versions, and integrate SPM packages into Xcode projects. The system parses Package.swift files, queries package registries, and handles dependency resolution conflicts.","intents":["I want to add a Swift package dependency to my project and resolve version conflicts","I need to update package dependencies and ensure compatibility","I want to query available versions of a package and choose the best version"],"best_for":["developers managing Swift package dependencies","AI agents that need to understand and modify package dependencies","teams automating dependency updates and security patches"],"limitations":["SPM dependency resolution can be slow for large dependency trees (>50 packages); may timeout on complex projects","Version conflict resolution is complex and may require manual intervention for incompatible versions","SPM integration with Xcode is not always seamless; some edge cases may require manual fixes"],"requires":["Swift 5.5+ (for SPM support)","Package.swift file in project root","internet connectivity for package registry queries"],"input_types":["package URL (string)","version requirement (string: exact, range, branch, etc.)","target name (string, optional)"],"output_types":["dependency list (JSON: [{name, version, url, dependencies}])","resolution result (JSON: {status, resolved_versions: {}})","compatibility check (JSON: {compatible: boolean, conflicts: []})"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_15","uri":"capability://automation.workflow.environment.aware.output.formatting.and.platform.detection","name":"environment-aware output formatting and platform detection","description":"Automatically detects execution environment (CLI terminal, MCP JSON-RPC, CI/CD system) and formats output accordingly (ANSI colors for terminals, JSON for agents, plain text for CI/CD logs). The system uses environment variables and output stream detection to choose appropriate formatting.","intents":["I want tool output to be human-readable in the terminal but JSON-structured for agents","I need CI/CD logs to be plain text without ANSI codes that clutter log files","I want the same tool to work seamlessly in CLI, MCP, and CI/CD contexts without configuration"],"best_for":["tools that need to work across multiple execution contexts (CLI, MCP, CI/CD)","developers who want human-readable output in terminals and structured output for automation","teams using the same tools in both interactive and non-interactive environments"],"limitations":["Output format detection is heuristic-based and may fail in edge cases (e.g., piped output to files)","ANSI color codes may not render correctly in all terminals; some CI/CD systems strip ANSI codes","JSON output can be verbose and difficult to read in terminals; requires pretty-printing for readability"],"requires":["environment variable support (TTY_DETECT, FORCE_JSON, etc.)","output stream detection (isatty() or equivalent)"],"input_types":["output data (any type)","environment variables (optional)"],"output_types":["formatted output (ANSI text for terminals, JSON for agents, plain text for CI/CD)"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_16","uri":"capability://automation.workflow.error.recovery.and.retry.logic.with.exponential.backoff","name":"error recovery and retry logic with exponential backoff","description":"Implements automatic error recovery for transient failures (network timeouts, simulator crashes, device disconnections) using exponential backoff retry logic. The system classifies errors as transient or permanent and applies appropriate recovery strategies.","intents":["I want tools to automatically retry on transient failures like simulator crashes","I need to handle device disconnections gracefully without failing the entire workflow","I want to avoid overwhelming the system with retries on permanent failures"],"best_for":["CI/CD systems that need resilience to transient failures","long-running workflows that may encounter simulator or device issues","teams that want to minimize manual intervention for transient failures"],"limitations":["Retry logic adds latency (exponential backoff can add 30+ seconds for multiple retries)","Error classification is heuristic-based; some errors may be misclassified as transient when they're permanent","Retries can mask underlying issues; excessive retries may hide systemic problems that need investigation"],"requires":["error classification logic in tool implementations","configurable retry parameters (max_retries, backoff_factor, etc.)"],"input_types":["error type (string)","retry configuration (JSON: {max_retries, backoff_factor, max_backoff})"],"output_types":["retry result (JSON: {status, attempts, final_error})"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_2","uri":"capability://tool.use.integration.schema.validated.tool.parameter.binding.with.type.safety","name":"schema-validated tool parameter binding with type safety","description":"Implements schema validation and type safety through manifest-driven tool definitions that specify parameter schemas, input/output types, and platform constraints. The system validates all tool invocations against these schemas before execution, catching parameter mismatches early and providing structured error messages to agents.","intents":["I want AI agents to invoke tools with guaranteed type safety and parameter validation","I need clear error messages when agents pass invalid parameters to build tools","I want to enforce platform-specific constraints (e.g., device workflows only on physical devices)"],"best_for":["teams using AI agents for iOS development who need guardrails against invalid tool usage","developers building custom tools on top of XcodeBuildMCP","systems requiring audit trails of tool invocations with validated parameters"],"limitations":["Schema validation adds ~50-100ms overhead per tool invocation for complex parameter sets","Custom schema extensions require modifying manifest files; no runtime schema generation from code","Schema validation is TypeScript-only; external tool consumers must implement their own validation"],"requires":["manifest files in tools/ directory with schema definitions","JSON Schema 2020-12 compatible parameter definitions","TypeScript 4.9+ for type inference from schemas"],"input_types":["tool manifest (JSON with schema definitions)","tool parameters (JSON matching schema)"],"output_types":["validation result (JSON: {valid: boolean, errors: []})","typed parameters (validated JSON)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_3","uri":"capability://data.processing.analysis.project.discovery.and.xcode.workspace.introspection","name":"project discovery and xcode workspace introspection","description":"Automatically discovers Xcode projects, workspaces, and Swift packages in the current directory and subdirectories, parsing project metadata (targets, schemes, build settings) without requiring manual configuration. The system maintains a project cache and provides tools to query available build targets, test schemes, and configuration options.","intents":["I want an AI agent to automatically detect my iOS project structure without manual setup","I need to query available build schemes and targets before invoking build tools","I want to discover Swift package dependencies and their build configurations"],"best_for":["developers working with multiple Xcode projects who want automatic discovery","AI agents that need to understand project structure before building","CI/CD systems that must adapt to different project layouts"],"limitations":["Project discovery is filesystem-based and may be slow on large monorepos (>10GB); caching helps but requires explicit cache invalidation","Workspace introspection requires parsing Xcode project files (XML); complex custom build configurations may not be fully understood","Swift Package Manager integration is limited to standard SPM layouts; custom package structures may not be detected"],"requires":["Xcode 14+ project files (.xcodeproj or .xcworkspace)","read access to project directory and subdirectories","optional: .xcodebuildmcp/config.yaml with project paths for faster discovery"],"input_types":["project directory path (string, optional; defaults to current directory)","search depth (integer, optional; defaults to 3 levels)"],"output_types":["project list (JSON: [{name, path, type, targets, schemes}])","target details (JSON: {name, type, dependencies, build_settings})","scheme information (JSON: {name, build_action, test_action, run_action})"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_4","uri":"capability://automation.workflow.build.execution.with.structured.output.and.error.capture","name":"build execution with structured output and error capture","description":"Wraps xcodebuild invocations with structured output parsing that captures build logs, compiler errors, warnings, and test results in JSON format. The system parses xcodebuild's unstructured output using regex patterns and structured logging, converting it into machine-readable JSON that agents can analyze and act upon.","intents":["I want to build an iOS app and get structured error messages that an AI agent can understand and fix","I need to capture build warnings and failures in JSON format for analysis and reporting","I want to extract compiler errors with file paths and line numbers for automated code fixes"],"best_for":["AI agents that need to parse build failures and suggest fixes","CI/CD systems that require machine-readable build output for analysis","developers building automated code repair tools on top of XcodeBuildMCP"],"limitations":["Output parsing relies on regex patterns that may break with Xcode version updates; requires maintenance for new Xcode releases","Large builds (>1000 files) can generate massive JSON output that exceeds agent context windows; requires streaming or pagination","Some Xcode warnings are non-deterministic or environment-specific; parsed output may not capture all edge cases"],"requires":["Xcode 14+ (for consistent xcodebuild output format)","valid Xcode project or workspace","build workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["project path (string)","scheme name (string)","configuration (string: Debug, Release)","destination (string: generic/platform=iOS Simulator, etc.)"],"output_types":["build result (JSON: {status, duration, errors: [], warnings: [], logs: []})","error details (JSON: {file, line, column, message, severity})","build artifacts (JSON: {app_path, dsym_path, build_log_path})"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_5","uri":"capability://automation.workflow.test.execution.with.coverage.and.result.aggregation","name":"test execution with coverage and result aggregation","description":"Orchestrates test execution through xcodebuild test, capturing test results in JSON format with per-test pass/fail status, execution time, and failure reasons. The system integrates with code coverage tools to generate coverage reports and aggregates results across multiple test targets and schemes.","intents":["I want to run iOS unit tests and get structured results that show which tests failed and why","I need to measure code coverage and track coverage trends across builds","I want to run tests in parallel across multiple simulators and aggregate results"],"best_for":["AI agents automating iOS test execution and failure analysis","CI/CD pipelines that need structured test results for reporting","teams tracking code coverage metrics and enforcing coverage thresholds"],"limitations":["Test result parsing depends on xcodebuild's output format; some test frameworks (XCTest, Quick, Nimble) have different output formats requiring custom parsers","Code coverage generation requires instrumenting binaries, adding 20-30% overhead to test execution time","Parallel test execution across simulators requires careful resource management; too many parallel tests can cause simulator crashes"],"requires":["Xcode 14+ with test targets defined","iOS simulator or physical device","test scheme configured in Xcode project"],"input_types":["scheme name (string)","test target (string, optional)","enable_coverage (boolean, optional; default: false)","parallel_workers (integer, optional; default: 1)"],"output_types":["test results (JSON: {total: int, passed: int, failed: int, tests: [{name, status, duration, failure_reason}]})","coverage report (JSON: {overall_coverage: float, file_coverage: [{file, coverage_percent}]})","test logs (text, optional)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_6","uri":"capability://automation.workflow.device.and.physical.device.management.with.provisioning","name":"device and physical device management with provisioning","description":"Provides tools to list connected physical iOS/macOS devices, manage provisioning profiles, and deploy built apps to devices. The system integrates with Xcode's device management APIs to query device capabilities, installed apps, and provisioning status, and handles the provisioning workflow for code signing.","intents":["I want to deploy a built iOS app to a physical device without manual Xcode interaction","I need to query connected devices and their capabilities before building","I want to manage provisioning profiles and code signing for device deployment"],"best_for":["teams testing on physical devices in CI/CD environments","AI agents that need to deploy and test on real hardware","developers automating device management workflows"],"limitations":["Physical device management requires USB connection and trust setup; cannot be fully automated without manual device pairing","Provisioning profile management is complex and error-prone; requires valid Apple Developer account and certificates","Device availability is unpredictable in CI/CD; devices may disconnect or become unavailable mid-deployment"],"requires":["physical iOS/macOS device connected via USB","device trust established (manual tap on device required once)","valid provisioning profile and code signing certificate","device workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["device UDID (string, optional; defaults to first connected device)","app bundle path (string)","provisioning profile name (string, optional)"],"output_types":["device list (JSON: [{udid, name, model, os_version, is_connected}])","device details (JSON: {udid, name, capabilities, installed_apps})","deployment status (JSON: {status, app_path, install_time})"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_7","uri":"capability://automation.workflow.macos.app.building.and.code.signing.with.entitlements","name":"macos app building and code signing with entitlements","description":"Provides specialized build workflows for macOS applications that handle code signing, entitlements configuration, and notarization. The system manages macOS-specific build settings and integrates with Apple's notarization service for distribution-ready builds.","intents":["I want to build a macOS app with proper code signing and entitlements","I need to notarize a macOS app for distribution outside the App Store","I want to manage macOS-specific build configurations and signing identities"],"best_for":["developers building and distributing macOS applications","AI agents automating macOS app builds with code signing","teams requiring notarized builds for distribution"],"limitations":["Notarization requires Apple Developer account and internet connectivity; can add 5-15 minutes to build time","Entitlements configuration is complex and error-prone; incorrect entitlements can cause app rejection or runtime failures","macOS-specific build settings differ significantly from iOS; agents may require macOS-specific prompting or training"],"requires":["Xcode 14+ with macOS SDK","valid code signing certificate and provisioning profile","Apple Developer account (for notarization)","macOS workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["scheme name (string)","signing identity (string, optional)","entitlements file path (string, optional)","notarize (boolean, optional; default: false)"],"output_types":["build result (JSON: {status, app_path, code_sign_status})","notarization status (JSON: {status, notarization_id, timestamp})","code signing details (JSON: {identity, team_id, entitlements})"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_8","uri":"capability://memory.knowledge.session.based.state.persistence.across.tool.invocations","name":"session-based state persistence across tool invocations","description":"Implements session management that persists tool state (selected project, simulator, device, build configuration) across multiple tool invocations without requiring agents to re-specify context. Sessions are stored in .xcodebuildmcp/sessions/ and automatically loaded based on session ID or environment variables.","intents":["I want to set a project once and have all subsequent tools use that project without re-specifying it","I need to maintain simulator state across multiple test runs without rebooting","I want to preserve build configuration choices across multiple build invocations"],"best_for":["long-running AI agents that invoke multiple tools sequentially","CI/CD pipelines that need to maintain context across multiple steps","developers working with multiple projects who want to switch context efficiently"],"limitations":["Session persistence requires filesystem access to .xcodebuildmcp/sessions/; not suitable for sandboxed or containerized environments","Sessions are not automatically cleaned up; old sessions can accumulate and consume disk space","Session state is not encrypted; sensitive information (API keys, provisioning profiles) should not be stored in sessions"],"requires":["write access to .xcodebuildmcp/sessions/ directory","session ID or XCODEBUILDMCP_SESSION environment variable","session management tools enabled in .xcodebuildmcp/config.yaml"],"input_types":["session ID (string, optional)","session data (JSON: {project_path, simulator_udid, device_udid, build_config})"],"output_types":["session info (JSON: {id, created_at, last_accessed, state})","session list (JSON: [{id, created_at, last_accessed}])"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-getsentry--xcodebuildmcp__cap_9","uri":"capability://automation.workflow.background.daemon.for.long.running.simulator.and.build.processes","name":"background daemon for long-running simulator and build processes","description":"Provides a background daemon (xcodebuildmcp daemon) that runs long-lived processes like simulator instances and build servers without blocking agent execution. The daemon manages process lifecycle, handles signal forwarding, and provides status queries through a socket-based IPC interface.","intents":["I want to boot a simulator once and keep it running for multiple test invocations without rebooting","I need to run a build server in the background and query its status without blocking the agent","I want to manage long-running processes that should persist across multiple tool calls"],"best_for":["agents running multiple sequential tests that benefit from simulator reuse","CI/CD systems that need to amortize simulator boot time across multiple test runs","developers building interactive development environments with persistent simulators"],"limitations":["Daemon process management adds complexity; daemon crashes can leave orphaned processes that consume resources","Socket-based IPC adds latency (~10-50ms per query) compared to in-process state management","Daemon state is not automatically persisted; daemon restart loses all running processes and requires manual recovery"],"requires":["Unix socket support (macOS only)","process management permissions (may require elevated privileges for some operations)","daemon workflow enabled in .xcodebuildmcp/config.yaml"],"input_types":["daemon command (string: start, stop, status, list)","process type (string: simulator, build_server, etc.)"],"output_types":["daemon status (JSON: {status, uptime, running_processes})","process list (JSON: [{pid, type, status, resource_usage}])"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":51,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+ (for TypeScript execution)","Xcode 14+ (for xcodebuild and simulator management)","macOS 12+ (for iOS simulator and device support)","MCP client (Cursor, Claude, VS Code with MCP extension) for agent mode","Xcode 14+ with iOS SDK","macOS 12+ with virtualization support","minimum 4GB free RAM per simulator instance","simulator workflow enabled in .xcodebuildmcp/config.yaml","Xcode 14+ with XCUITest framework","iOS simulator or physical device"],"failure_modes":["Dual-mode design adds complexity to tool development — changes must be validated in both CLI and MCP contexts","Context window optimization defaults to simulator-only tools; enabling all 77 tools may exceed agent token budgets","TypeScript-only implementation — no native Python or Go bindings for alternative MCP clients","Simulator management is resource-intensive — running multiple simulators simultaneously requires 8GB+ RAM and can exceed agent context windows","Simulator state persistence requires explicit session management; transient agents without session support may lose simulator context between invocations","iOS simulator availability is macOS-only; no support for Android or cloud-based simulators","XCUITest execution is slow (5-30 seconds per test) due to simulator overhead; not suitable for rapid iteration","UI test flakiness is common due to timing issues and simulator variability; tests may fail intermittently","Screen recording and accessibility audits add significant overhead; can increase test execution time by 50%+","Coverage measurement requires instrumenting binaries, adding 20-30% overhead to test execution","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.5739831767811188,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:56:59.048Z","last_commit":"2026-05-03T08:13:17Z"},"community":{"stars":5397,"forks":265,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=getsentry--xcodebuildmcp","compare_url":"https://unfragile.ai/compare?artifact=getsentry--xcodebuildmcp"}},"signature":"dIdIoaXlpXj3R6MkCePM09O5rwhEudD1e+70R3Zv2jgnGLo7e49VMlC0gFDZkDtIwarmFXrb1urv/TZ0moTKCQ==","signedAt":"2026-06-19T22:09:53.580Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/getsentry--xcodebuildmcp","artifact":"https://unfragile.ai/getsentry--xcodebuildmcp","verify":"https://unfragile.ai/api/v1/verify?slug=getsentry--xcodebuildmcp","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}