Mac Mini M4 पर CircleCI सेल्फ-होस्टेड रनर कैसे सेट करें

1. Mac पर सेल्फ-होस्टेड CircleCI रनर क्यों उपयोग करें?

CircleCI क्लाउड-आधारित macOS एक्ज़ीक्यूशन वातावरण प्रदान करता है, लेकिन ये महत्वपूर्ण लागतों और सीमाओं के साथ आते हैं। CircleCI पर macOS संसाधन एक क्रेडिट-आधारित प्रणाली का उपयोग करते हैं, जहाँ macOS एक्ज़ीक्यूटर पर प्रत्येक मिनट रिसोर्स क्लास के आधार पर 50-100 क्रेडिट खपत करता है। अक्सर iOS बिल्ड चलाने वाली टीमों के लिए, यह जल्दी ही प्रति माह $300-$500 या उससे अधिक तक पहुँच सकता है।

MyRemoteMac के एक समर्पित Mac Mini M4 पर एक सेल्फ-होस्टेड रनर प्रति-मिनट बिलिंग को पूरी तरह समाप्त कर देता है। आपको स्थायी स्टोरेज, वार्म कैश, और पूर्ण रूट एक्सेस वाली एक समर्पित Apple Silicon मशीन एक फ्लैट मासिक शुल्क पर मिलती है, जो $85/माह से शुरू होता है। यहाँ एक विस्तृत तुलना है:

2. पूर्वापेक्षाएँ

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित हैं:

• MyRemoteMac से एक Mac Mini M4 सर्वर ($85/माह से)
• Performance, Scale, या Server प्लान वाला एक CircleCI खाता (सेल्फ-होस्टेड रनर के लिए एक सशुल्क प्लान आवश्यक है)
• आपके Mac Mini तक SSH एक्सेस (आपकी MyRemoteMac सदस्यता के साथ प्रदान किया गया)
• एक Apple Developer खाता (कोड साइनिंग और प्रोविज़निंग प्रोफ़ाइल के लिए)
• YAML, CircleCI कॉन्फ़िगरेशन, और टर्मिनल कमांड से बुनियादी परिचय

3. चरण 1: अपने Mac Mini में SSH करें और डिपेंडेंसी इंस्टॉल करें

सबसे पहले, SSH के ज़रिए अपने Mac Mini M4 से कनेक्ट करें। जब आपने अपना MyRemoteMac सर्वर सेट किया था तब आपको अपने क्रेडेंशियल मिले होंगे। CircleCI रनर सेट करने से पहले हमें Xcode और iOS बिल्ड के लिए आवश्यक टूल इंस्टॉल करने होंगे।

SSH के ज़रिए कनेक्ट करें

# Connect to your Mac Mini M4
ssh admin@your-server-ip

# Verify you're on Apple Silicon
uname -m
# Expected output: arm64

# Check macOS version
sw_vers
# ProductName:    macOS
# ProductVersion: 15.2
# BuildVersion:   24C101

Homebrew और Xcode Command Line Tools इंस्टॉल करें

# Install Homebrew (if not already installed)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Add Homebrew to PATH
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

# Install Xcode Command Line Tools
xcode-select --install

# Accept the license agreement
sudo xcodebuild -license accept

Xcode इंस्टॉल करें (पूर्ण संस्करण)

iOS बिल्ड के लिए, आपको पूर्ण Xcode एप्लिकेशन की आवश्यकता होती है। इसे हेडलेस सर्वर पर इंस्टॉल करने का सबसे तेज़ तरीका xcodes का उपयोग करना है:

# Install xcodes CLI tool
brew install xcodes

# List available Xcode versions
xcodes list

# Install the latest stable Xcode
xcodes install 16.2

# Set it as the active Xcode
sudo xcode-select -s /Applications/Xcode-16.2.app/Contents/Developer

# Verify installation
xcodebuild -version
# Xcode 16.2
# Build version 16C5032a

iOS सिम्युलेटर और बिल्ड टूल इंस्टॉल करें

# Install the iOS 18 simulator runtime
xcodebuild -downloadPlatform iOS

# Verify simulator availability
xcrun simctl list runtimes
# == Runtimes ==
# iOS 18.2 (18.2 - 22C150) - com.apple.CoreSimulator.SimRuntime.iOS-18-2

# Install additional build tools
brew install xcbeautify fastlane swiftlint

4. चरण 2: CircleCI रनर एजेंट इंस्टॉल करें

CircleCI आपके Mac Mini को CircleCI प्लेटफ़ॉर्म से जोड़ने के लिए एक मशीन रनर एजेंट का उपयोग करता है। मशीन रनर CircleCI से जॉब्स प्राप्त करता है और उन्हें सीधे आपके macOS होस्ट पर एक्ज़ीक्यूट करता है। यह कंटेनर रनर से अलग है (जो केवल Linux पर काम करता है)।

रनर के लिए एक समर्पित उपयोगकर्ता बनाएं

सुरक्षा आइसोलेशन के लिए CircleCI एजेंट चलाने हेतु एक समर्पित उपयोगकर्ता बनाने की सलाह दी जाती है:

# Create a circleci user (optional but recommended)
sudo dscl . -create /Users/circleci
sudo dscl . -create /Users/circleci UserShell /bin/zsh
sudo dscl . -create /Users/circleci RealName "CircleCI Runner"
sudo dscl . -create /Users/circleci UniqueID 550
sudo dscl . -create /Users/circleci PrimaryGroupID 20
sudo dscl . -create /Users/circleci NFSHomeDirectory /Users/circleci
sudo mkdir -p /Users/circleci
sudo chown circleci:staff /Users/circleci

# Or simply use your existing admin user (simpler setup)

रनर एजेंट डाउनलोड और इंस्टॉल करें

# Create a directory for the runner
sudo mkdir -p /opt/circleci

# Download the latest CircleCI machine runner for macOS ARM64
# Check https://circleci.com/docs/runner-installation-mac/ for latest version
curl -o /tmp/circleci-runner.pkg \
  https://circleci-binary-releases.s3.amazonaws.com/circleci-runner/1.0/circleci-runner_darwin_arm64.pkg

# Install the runner package
sudo installer -pkg /tmp/circleci-runner.pkg -target /

# Verify the installation
circleci-runner --version

रनर एजेंट कॉन्फ़िगर करें

रनर कॉन्फ़िगरेशन फ़ाइल बनाएं। आपको CircleCI डैशबोर्ड से अपने रनर प्रमाणीकरण टोकन की आवश्यकता होगी (चरण 3 में शामिल)। अभी के लिए, कॉन्फ़िग फ़ाइल संरचना बनाएं:

# Create the configuration directory
sudo mkdir -p /opt/circleci/config

# Create the runner configuration file
sudo tee /opt/circleci/config/runner-agent-config.yaml << 'EOF'
api:
  auth_token: YOUR_RUNNER_TOKEN_HERE

runner:
  name: mac-mini-m4-runner
  working_directory: /opt/circleci/workdir
  cleanup_working_directory: true
  max_run_time: 5h

  # Optional: limit concurrent tasks
  # command_prefix: ["nice", "-n", "10"]

logging:
  file: /opt/circleci/logs/runner.log
EOF

# Create required directories
sudo mkdir -p /opt/circleci/workdir
sudo mkdir -p /opt/circleci/logs

# Set permissions (adjust user if using dedicated circleci user)
sudo chown -R admin:staff /opt/circleci

परसिस्टेंस के लिए एक macOS Launch Agent बनाएं

यह सुनिश्चित करने के लिए कि रनर बूट पर स्वचालित रूप से शुरू हो और क्रैश होने पर पुनः शुरू हो, एक macOS LaunchDaemon बनाएं:

# Create the LaunchDaemon plist
sudo tee /Library/LaunchDaemons/com.circleci.runner.plist << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.circleci.runner</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/circleci/circleci-runner</string>
        <string>machine</string>
        <string>--config</string>
        <string>/opt/circleci/config/runner-agent-config.yaml</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>StandardOutPath</key>
    <string>/opt/circleci/logs/runner-stdout.log</string>
    <key>StandardErrorPath</key>
    <string>/opt/circleci/logs/runner-stderr.log</string>
    <key>EnvironmentVariables</key>
    <dict>
        <key>PATH</key>
        <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
    </dict>
</dict>
</plist>
EOF

# Load and start the service
sudo launchctl load /Library/LaunchDaemons/com.circleci.runner.plist

# Verify the service is running
sudo launchctl list | grep circleci
# Expected: PID listed with com.circleci.runner

# Check the logs
tail -f /opt/circleci/logs/runner.log

5. चरण 3: CircleCI डैशबोर्ड में रनर कॉन्फ़िगर करें

अब आपको CircleCI वेब इंटरफ़ेस में अपना रनर पंजीकृत करना होगा और एक प्रमाणीकरण टोकन जनरेट करना होगा। यह आपके Mac Mini को आपके CircleCI संगठन से जोड़ता है।

एक रिसोर्स क्लास बनाएं

CircleCI में, सेल्फ-होस्टेड रनर रिसोर्स क्लास द्वारा व्यवस्थित होते हैं। एक रिसोर्स क्लास एक लेबल है जो आपके .circleci/config.yml को रनर के एक विशिष्ट सेट से मैप करता है।

1. CircleCI डैशबोर्ड → Organization Settings → Self-Hosted Runners पर जाएं
2. "Create Resource Class" पर क्लिक करें
3. Namespace को अपने संगठन के नाम पर सेट करें (उदाहरण: your-org)
4. Resource Class नाम को कुछ वर्णनात्मक पर सेट करें (उदाहरण: mac-runner)
5. इससे एक रिसोर्स क्लास पहचानकर्ता बनता है: your-org/mac-runner

एक रनर प्रमाणीकरण टोकन जनरेट करें

1. रिसोर्स क्लास बनाने के बाद, "Create New Token" पर क्लिक करें
2. टोकन को एक वर्णनात्मक नाम दें (उदाहरण: mac-mini-m4-token)
3. जनरेट किए गए टोकन को तुरंत कॉपी करें — यह केवल एक बार दिखाया जाएगा

अपने टोकन के साथ रनर कॉन्फ़िगरेशन अपडेट करें

# SSH back into your Mac Mini
ssh admin@your-server-ip

# Update the runner configuration with your real token
sudo nano /opt/circleci/config/runner-agent-config.yaml

# Replace YOUR_RUNNER_TOKEN_HERE with the actual token:
# api:
#   auth_token: eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...

# Restart the runner service to apply the new token
sudo launchctl unload /Library/LaunchDaemons/com.circleci.runner.plist
sudo launchctl load /Library/LaunchDaemons/com.circleci.runner.plist

# Verify the runner connects successfully
tail -20 /opt/circleci/logs/runner.log
# Look for: "Runner is ready to receive jobs"

कनेक्ट होने के बाद, रनर को CircleCI डैशबोर्ड में Self-Hosted Runners के अंतर्गत "Online" के रूप में दिखना चाहिए। यदि यह 60 सेकंड के भीतर नहीं दिखता, तो त्रुटि संदेशों के लिए लॉग फ़ाइल जाँचें।

CircleCI CLI का उपयोग करना (वैकल्पिक)

आप CircleCI CLI के ज़रिए भी रनर प्रबंधित कर सकते हैं:

# Install the CircleCI CLI
brew install circleci

# Authenticate with CircleCI
circleci setup

# Create a resource class via CLI
circleci runner resource-class create your-org/mac-runner \
  "Mac Mini M4 Runner" --generate-token

# List your runners
circleci runner instance list your-org/mac-runner

6. चरण 4: iOS बिल्ड के लिए अपना .circleci/config.yml बनाएं

अपने रिपॉज़िटरी के रूट में एक .circleci/config.yml फ़ाइल बनाएं। एक मानक CircleCI कॉन्फ़िग से मुख्य अंतर यह है कि अपने सेल्फ-होस्टेड रनर को टारगेट करने के लिए अपने कस्टम resource_class के साथ machine: true का उपयोग किया जाता है।

version: 2.1

jobs:
  build-and-test:
    machine: true
    resource_class: your-org/mac-runner

    environment:
      SCHEME: "MyApp"
      DESTINATION: "platform=iOS Simulator,name=iPhone 16 Pro,OS=18.2"
      DERIVED_DATA_PATH: "DerivedData"
      SPM_CACHE_PATH: ".spm-cache"

    steps:
      - checkout

      - run:
          name: Select Xcode version
          command: |
            sudo xcode-select -s /Applications/Xcode-16.2.app/Contents/Developer
            xcodebuild -version

      - run:
          name: Resolve Swift Package Dependencies
          command: |
            xcodebuild -resolvePackageDependencies \
              -scheme "$SCHEME" \
              -clonedSourcePackagesDirPath "$SPM_CACHE_PATH"

      - run:
          name: Build the app
          command: |
            xcodebuild build \
              -scheme "$SCHEME" \
              -destination "$DESTINATION" \
              -clonedSourcePackagesDirPath "$SPM_CACHE_PATH" \
              -derivedDataPath "$DERIVED_DATA_PATH" \
              | xcbeautify

      - run:
          name: Run unit tests
          command: |
            xcodebuild test \
              -scheme "$SCHEME" \
              -destination "$DESTINATION" \
              -clonedSourcePackagesDirPath "$SPM_CACHE_PATH" \
              -derivedDataPath "$DERIVED_DATA_PATH" \
              -resultBundlePath TestResults.xcresult \
              | xcbeautify

      - store_test_results:
          path: TestResults.xcresult

      - store_artifacts:
          path: TestResults.xcresult
          destination: test-results

workflows:
  ios-pipeline:
    jobs:
      - build-and-test:
          filters:
            branches:
              only:
                - main
                - develop

7. चरण 5: कैशिंग और पैरेललिज़्म के साथ ऑप्टिमाइज़ करें

सेल्फ-होस्टेड रनर के सबसे बड़े लाभों में से एक स्थायी कैशिंग है। चूँकि रनर का फ़ाइलसिस्टम स्थायी होता है, आपको CircleCI क्लाउड संसाधनों की तरह कैश अपलोड और डाउनलोड करने की आवश्यकता नहीं होती। हालाँकि, अपनी बिल्ड गति को अधिकतम करने के लिए अतिरिक्त ऑप्टिमाइज़ेशन मौजूद हैं।

स्थायी DerivedData का लाभ उठाएं

चूँकि रनर डिस्क बिल्ड के बीच बनी रहती है, DerivedData पहले से ही स्वचालित रूप से कैश हो जाता है। एक सुसंगत पथ का उपयोग करें:

# In your config.yml steps, always use a consistent DerivedData path:
- run:
    name: Build with persistent cache
    command: |
      xcodebuild build \
        -scheme "$SCHEME" \
        -destination "$DESTINATION" \
        -derivedDataPath ~/DerivedData/"$SCHEME" \
        -clonedSourcePackagesDirPath ~/spm-cache \
        | xcbeautify

# Periodically clean old DerivedData on the runner (cron job):
# 0 3 * * 0 find ~/DerivedData -maxdepth 1 -mtime +7 -exec rm -rf {} +

जॉब्स के बीच वर्कस्पेस परसिस्टेंस

एक ही वर्कफ़्लो में जॉब्स के बीच आर्टिफ़ैक्ट पास करने के लिए CircleCI वर्कस्पेस का उपयोग करें:

jobs:
  build:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - run:
          name: Build
          command: |
            xcodebuild build \
              -scheme "MyApp" \
              -destination "generic/platform=iOS" \
              -derivedDataPath DerivedData
      - persist_to_workspace:
          root: .
          paths:
            - DerivedData

  test:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - attach_workspace:
          at: .
      - run:
          name: Run tests
          command: |
            xcodebuild test \
              -scheme "MyApp" \
              -destination "platform=iOS Simulator,name=iPhone 16 Pro,OS=18.2" \
              -derivedDataPath DerivedData \
              | xcbeautify

workflows:
  build-test:
    jobs:
      - build
      - test:
          requires:
            - build

पैरेलल टेस्ट एक्ज़ीक्यूशन

- run:
    name: Run tests in parallel
    command: |
      xcodebuild test \
        -scheme "MyApp" \
        -destination "platform=iOS Simulator,name=iPhone 16 Pro,OS=18.2" \
        -destination "platform=iOS Simulator,name=iPhone 15,OS=17.5" \
        -parallel-testing-enabled YES \
        -maximum-parallel-testing-workers 4 \
        -derivedDataPath DerivedData \
        | xcbeautify

CircleCI टेस्ट स्प्लिटिंग

बड़े टेस्ट सूट के लिए, पैरेलल रनर में टेस्ट वितरित करने के लिए CircleCI की अंतर्निहित टेस्ट स्प्लिटिंग का उपयोग करें:

jobs:
  test:
    machine: true
    resource_class: your-org/mac-runner
    parallelism: 3
    steps:
      - checkout
      - run:
          name: Split and run tests
          command: |
            # Generate test plan
            TESTS=$(circleci tests glob "**/*Tests.swift" | \
              circleci tests split --split-by=timings)

            # Run only this container's portion of tests
            xcodebuild test \
              -scheme "MyApp" \
              -destination "platform=iOS Simulator,name=iPhone 16 Pro,OS=18.2" \
              -only-testing:$TESTS \
              | xcbeautify

8. वर्कफ़्लो उदाहरण

सामान्य iOS CI/CD परिदृश्यों के लिए यहाँ संपूर्ण, प्रोडक्शन-रेडी वर्कफ़्लो उदाहरण दिए गए हैं।

संपूर्ण iOS बिल्ड, टेस्ट, और डिप्लॉय पाइपलाइन

version: 2.1

jobs:
  lint:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - run:
          name: Run SwiftLint
          command: swiftlint lint --reporter json > swiftlint-results.json || true
      - store_artifacts:
          path: swiftlint-results.json

  build-and-test:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - run:
          name: Select Xcode
          command: sudo xcode-select -s /Applications/Xcode-16.2.app/Contents/Developer
      - run:
          name: Resolve dependencies
          command: |
            xcodebuild -resolvePackageDependencies \
              -scheme "MyApp" \
              -clonedSourcePackagesDirPath ~/spm-cache
      - run:
          name: Build and test
          command: |
            xcodebuild test \
              -scheme "MyApp" \
              -destination "platform=iOS Simulator,name=iPhone 16 Pro,OS=18.2" \
              -clonedSourcePackagesDirPath ~/spm-cache \
              -derivedDataPath ~/DerivedData/MyApp \
              -resultBundlePath TestResults.xcresult \
              -parallel-testing-enabled YES \
              | xcbeautify
      - store_test_results:
          path: TestResults.xcresult
      - store_artifacts:
          path: TestResults.xcresult

  deploy-testflight:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - run:
          name: Select Xcode
          command: sudo xcode-select -s /Applications/Xcode-16.2.app/Contents/Developer
      - run:
          name: Install certificates with Fastlane Match
          command: |
            fastlane match appstore --readonly
      - run:
          name: Build and upload to TestFlight
          command: |
            fastlane beta
          environment:
            FASTLANE_USER: ${APPLE_ID}
            MATCH_PASSWORD: ${MATCH_PASSWORD}

workflows:
  ios-pipeline:
    jobs:
      - lint
      - build-and-test:
          requires:
            - lint
      - deploy-testflight:
          requires:
            - build-and-test
          filters:
            branches:
              only: main

Fastlane एकीकरण उदाहरण

यदि आप अपने बिल्ड ऑटोमेशन के लिए Fastlane का उपयोग करते हैं, तो इसे अपने CircleCI सेल्फ-होस्टेड रनर के साथ एकीकृत करने का तरीका यहाँ दिया गया है:

# Fastfile (fastlane/Fastfile)
default_platform(:ios)

platform :ios do
  desc "Run tests"
  lane :test do
    scan(
      scheme: "MyApp",
      device: "iPhone 16 Pro",
      derived_data_path: "~/DerivedData/MyApp",
      result_bundle: true,
      output_directory: "./test_output"
    )
  end

  desc "Build and push to TestFlight"
  lane :beta do
    match(type: "appstore", readonly: true)
    increment_build_number(
      build_number: ENV["CIRCLE_BUILD_NUM"]
    )
    gym(
      scheme: "MyApp",
      export_method: "app-store",
      derived_data_path: "~/DerivedData/MyApp"
    )
    pilot(skip_waiting_for_build_processing: true)
  end
end

# .circleci/config.yml using Fastlane
version: 2.1

jobs:
  fastlane-test:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - run:
          name: Install dependencies
          command: bundle install
      - run:
          name: Run Fastlane tests
          command: bundle exec fastlane test
      - store_test_results:
          path: ./test_output
      - store_artifacts:
          path: ./test_output

  fastlane-deploy:
    machine: true
    resource_class: your-org/mac-runner
    steps:
      - checkout
      - run:
          name: Install dependencies
          command: bundle install
      - run:
          name: Deploy to TestFlight
          command: bundle exec fastlane beta

workflows:
  ios-workflow:
    jobs:
      - fastlane-test
      - fastlane-deploy:
          requires:
            - fastlane-test
          filters:
            branches:
              only: main

9. प्रदर्शन तुलना

CircleCI क्लाउड macOS संसाधनों और MyRemoteMac के एक सेल्फ-होस्टेड Mac Mini M4 के बीच यहाँ एक विस्तृत प्रदर्शन और लागत तुलना दी गई है:

बिल्ड समय बेंचमार्क

मासिक लागत विश्लेषण

10. सामान्य समस्याओं का निवारण

# Check if the process is running
ps aux | grep circleci-runner

# Check the LaunchDaemon status
sudo launchctl list | grep circleci

# View the error logs
tail -50 /opt/circleci/logs/runner-stderr.log
tail -50 /opt/circleci/logs/runner.log

# Restart the service
sudo launchctl unload /Library/LaunchDaemons/com.circleci.runner.plist
sudo launchctl load /Library/LaunchDaemons/com.circleci.runner.plist

# If the token expired, generate a new one in CircleCI dashboard
# and update /opt/circleci/config/runner-agent-config.yaml

# Verify the exact resource class name in CircleCI dashboard:
# Organization Settings > Self-Hosted Runners > Resource Classes

# The resource_class in .circleci/config.yml must match exactly:
# resource_class: your-org/mac-runner  (case-sensitive!)

# Check your runner is online:
circleci runner instance list your-org/mac-runner

# Common mistakes:
# - Wrong namespace (org name vs personal namespace)
# - Typo in resource class name
# - Runner is offline or token is invalid
# - Using 'docker' executor instead of 'machine: true'

# Option 1: Use Fastlane Match (recommended)
# In your Fastfile:
match(type: "appstore", readonly: true)

# Option 2: Manual keychain management in your job steps
- run:
    name: Setup code signing
    command: |
      # Decode and import the certificate
      echo "$BUILD_CERTIFICATE_BASE64" | base64 --decode > /tmp/cert.p12

      # Create a temporary keychain
      security create-keychain -p "ci" /tmp/ci.keychain
      security set-keychain-settings -lut 21600 /tmp/ci.keychain
      security unlock-keychain -p "ci" /tmp/ci.keychain

      # Import the certificate
      security import /tmp/cert.p12 -P "$P12_PASSWORD" \
        -A -t cert -f pkcs12 -k /tmp/ci.keychain
      security list-keychain -d user -s /tmp/ci.keychain

      # Install provisioning profile
      mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
      echo "$PROVISIONING_PROFILE_BASE64" | base64 --decode \
        > ~/Library/MobileDevice/Provisioning\ Profiles/profile.mobileprovision

# Add a pre-build step to clean simulators
- run:
    name: Reset simulators
    command: |
      xcrun simctl shutdown all 2>/dev/null || true
      xcrun simctl erase all 2>/dev/null || true

# If a specific runtime is missing, reinstall it:
xcodebuild -downloadPlatform iOS

# List available simulators
xcrun simctl list devices available

# Check available disk space
df -h /

# Clean old DerivedData
rm -rf ~/Library/Developer/Xcode/DerivedData/*

# Remove old simulator runtimes
xcrun simctl runtime delete all

# Clean Homebrew cache
brew cleanup --prune=7

# Remove old CircleCI working directories
find /opt/circleci/workdir -maxdepth 1 -mtime +3 -exec rm -rf {} +

# Set up a weekly cron job for automatic cleanup
(crontab -l 2>/dev/null; echo "0 4 * * 0 rm -rf ~/Library/Developer/Xcode/DerivedData/* && brew cleanup --prune=7") | crontab -

11. अक्सर पूछे जाने वाले प्रश्न

12. संबंधित गाइड