Fan-out / fan-in builds

workflows:
  build-module-a:
    name: Build Module A (Android)
    instance_type: linux_x2
    environment:
      groups:
        - orchestration_credentials
      android_signing:
        - module_a_keystore   # reference name from Team Settings → Code signing identities
    scripts:
      - name: Build release AAR
        script: | 
          # Codemagic has already placed the keystore on disk and exported
          # CM_KEYSTORE_PATH, CM_KEYSTORE_PASSWORD, CM_KEY_ALIAS, CM_KEY_PASSWORD.
          # Gradle reads these via signingConfigs.release in build.gradle — no flags needed.
          ./gradlew :module-a:assembleRelease
        when:
          changeset:
            includes:
              - 'modules/module-a/**'
    artifacts:
      - modules/module-a/build/outputs/**/*.aar

workflows:
  build-module-b:
    name: Build Module B (iOS framework)
    instance_type: mac_mini_m2
    integrations:
      app_store_connect: YOUR_API_KEY_NAME   # configured in Team Settings → Integrations
    environment:
      groups:
        - orchestration_credentials
      ios_signing:
        distribution_type: development
        bundle_identifier: io.codemagic.moduleB
      vars:
        XCODE_SCHEME: "ModuleB"
      xcode: latest
    
    scripts:
      - name: Set up code signing
        script: xcode-project use-profiles
    
      - name: Build XCFramework
        script: | 
          xcodebuild archive                          \
            -scheme "$XCODE_SCHEME"                   \
            -destination "generic/platform=iOS"       \
            -archivePath build/ModuleB-iOS.xcarchive  \
            SKIP_INSTALL=NO                           \
            BUILD_LIBRARY_FOR_DISTRIBUTION=YES
        
          xcodebuild -create-xcframework \
            -framework build/ModuleB-iOS.xcarchive/Products/Library/Frameworks/ModuleB.framework \
            -output build/ModuleB.xcframework
        when:
          changeset:
            includes:
              - 'modules/module-b/**'
    
    artifacts:
      - build/ModuleB.xcframework/**

workflows:
  build-module-generic:
    name: Build Module (parameterised)
    instance_type: mac_mini_m2
    environment:
      groups:
        - orchestration_credentials
      android_signing:
        - module_keystore_reference
      vars:
        # These are overridden at trigger time by the coordinator script.
        # Defaults here allow manual test runs from the Codemagic UI.
        MODULE_NAME: "module-c"
        MODULE_PATH: "modules/module-c"
    scripts:
      - name: Build module
        script: | 
          echo "Building $MODULE_NAME from $MODULE_PATH"
          ./gradlew :${MODULE_NAME}:assembleRelease

          # Copy artifact to a fixed path so the artifacts glob below can find it
          mkdir -p build/module-output
          find "$MODULE_PATH/build/outputs" -name "*.aar" \
            -exec cp {} build/module-output/ \;
        when:
          changeset:
            includes:
              - 'modules/**'
    artifacts:
      - build/module-output/*.aar

#!/usr/bin/env python3
"""
Fan-out / fan-in coordinator for Codemagic.

Triggers module builds in parallel via the REST API, waits for all to
complete, collects artifact URLs, and triggers the host app build with
those URLs injected as environment variables.

Required environment variables:
  CM_API_TOKEN   - Codemagic API token (mark as Secret)
  CM_APP_ID      - Codemagic App ID for this repository
  CM_TEAM_ID     - Codemagic team ID
  CM_BRANCH      - Branch to build (set automatically by Codemagic)
"""

import os, sys, json, time, urllib.request, urllib.error

# --- CONFIGURATION ---
# Each entry is either:
#   - A plain workflow ID string (uses no extra variables), or
#   - A dict with 'workflow_id', 'env' (extra variables), and 'artifact_ext'
#     for workflows that require runtime parameters or produce different artifact types.
MODULE_BUILDS = [
    # Module A: dedicated Android workflow, no extra parameters needed
    {
        "workflow_id":    "build-module-a",
        "artifact_ext":   ".aar",
    },
    # Module B: dedicated iOS workflow, no extra parameters needed
    {
        "workflow_id":    "build-module-b",
        "artifact_ext":   ".xcframework",
    },
    # Module C: generic parameterised workflow — pass module identity at runtime
    {
        "workflow_id":    "build-module-generic",
        "artifact_ext":   ".aar",
        "env": {
            "MODULE_NAME": "module-c",
            "MODULE_PATH": "modules/module-c",
        },
    },
    # Add more modules here. For additional generic modules, duplicate the
    # last entry and change MODULE_NAME / MODULE_PATH. The same
    # build-module-generic workflow ID is reused each time.
]

HOST_WORKFLOW_ID  = "build-host-app"
POLL_INTERVAL     = 30       # seconds between status checks
TIMEOUT_SECONDS   = 7200     # 2 hours maximum wait
TERMINAL_STATUSES = {"finished", "failed", "canceled", "timeout", "skipped"}

API_BASE    = "https://api.codemagic.io"
API_V3_BASE = "https://codemagic.io/api/v3"

def get_env(name):
    value = os.environ.get(name)
    if not value:
        print(f"ERROR: Required environment variable '{name}' is not set.")
        sys.exit(1)
    return value

def api_request(method, url, data=None, token=None):
    headers = {"Content-Type": "application/json"}
    if token:
        headers["x-auth-token"] = token
    body = json.dumps(data).encode() if data else None
    req  = urllib.request.Request(url, data=body, headers=headers, method=method)
    try:
        with urllib.request.urlopen(req) as r:
            return json.loads(r.read().decode())
    except urllib.error.HTTPError as e:
        print(f"HTTP {e.code} for {method} {url}: {e.read().decode()}")
        raise

def trigger_build(app_id, workflow_id, branch, token, extra_env=None):
    payload = {"appId": app_id, "workflowId": workflow_id, "branch": branch}
    if extra_env:
        payload["environment"] = {"variables": extra_env}
    result   = api_request("POST", f"{API_BASE}/builds", data=payload, token=token)
    build_id = result.get("buildId")
    if not build_id:
        print(f"ERROR: No buildId returned for {workflow_id}. Response: {result}")
        sys.exit(1)
    print(f"  Triggered {workflow_id} → {build_id}")
    return build_id

def get_build(build_id, token):
    url = f"{API_BASE}/builds/{build_id}"
    return api_request("GET", url, token=token) # Returns the single build dictionary directly

def wait_for_builds(build_ids, team_id, token):
    """Poll until all builds reach a terminal status. Abort on any failure."""
    pending = set(build_ids)
    results = {}
    elapsed = 0
    while pending:
        if elapsed >= TIMEOUT_SECONDS:
            print(f"ERROR: Timed out after {TIMEOUT_SECONDS}s. Still pending: {pending}")
            sys.exit(1)
        time.sleep(POLL_INTERVAL)
        elapsed += POLL_INTERVAL
        for bid in list(pending):
            build  = get_build(bid, team_id, token)
            status = build.get("status", "unknown")
            if status in TERMINAL_STATUSES:
                pending.discard(bid)
                results[bid] = build
                print(f"  Build {bid} → {status}")
                if status not in {"finished", "skipped"}:
                    print(f"ERROR: Build {bid} ended with '{status}'. Aborting.")
                    sys.exit(1)
        if pending:
            print(f"  Waiting ({elapsed}s elapsed, {len(pending)} build(s) still running)...")
    return results

def extract_artifact_url(build_result, ext):
    for artifact in build_result.get("artifacts", []):
        if artifact.get("name", "").endswith(ext):
            return artifact.get("short_lived_download_url")
    return None

def main():
    token   = get_env("CM_API_TOKEN")
    app_id  = get_env("CM_APP_ID")
    branch  = get_env("CM_BRANCH")
    team_id = get_env("CM_TEAM_ID")

    # FAN OUT: trigger all module builds simultaneously
    print(f"\n=== Fanning out to {len(MODULE_BUILDS)} module build(s) on '{branch}' ===")
    triggered = []  # list of (build_id, module_config)
    for module in MODULE_BUILDS:
        wf_id    = module["workflow_id"]
        extra    = module.get("env")
        build_id = trigger_build(app_id, wf_id, branch, token, extra_env=extra)
        triggered.append((build_id, module))

    # WAIT: poll until every module build is done
    print("\n=== Waiting for all module builds ===")
    build_id_map = {build_id: module for build_id, module in triggered}
    results      = wait_for_builds(list(build_id_map.keys()), team_id, token)

    # COLLECT artifacts — one URL per module, keyed by workflow ID.
    # If a step-level changeset condition was skipped, no artifact is generated.
    print("\n=== Collecting artifact URLs ===")
    artifact_env = {}
    for build_id, result in results.items():
        module = build_id_map[build_id]
        wf_id  = module["workflow_id"]
        
        ext = module.get("artifact_ext", ".aar")
        url = extract_artifact_url(result, ext)
        
        if not url:
            # Because the API build status returns "finished" even if internal steps skip,
            # a successful build without an artifact signals that the module had no source changes.
            print(f"  {wf_id} produced no {ext} artifact — assuming step skipped (no changes)")
            continue
            
        # Derive a clean env var name, e.g. "build-module-a" → "MODULE_A_ARTIFACT_URL"
        key = wf_id.upper().replace("-", "_").replace("BUILD_", "") + "_ARTIFACT_URL"
        artifact_env[key] = url
        print(f"  {key} = {url[:60]}...")

    # FAN IN: trigger host app build with all artifact URLs
    print(f"\n=== Fanning in: triggering {HOST_WORKFLOW_ID} ===")
    trigger_build(app_id, HOST_WORKFLOW_ID, branch, token, extra_env=artifact_env)
    print("\n=== Done. All module builds succeeded. Host build triggered. ===")

if __name__ == "__main__":
    main()

workflows:
  # --- COORDINATOR ---
  # Triggered by git push. Runs no builds itself — orchestrates everything via API.
  # Uses linux_x2 because it only runs a Python script; no mobile toolchain needed.
  coordinator:
    name: Coordinator (fan-out / fan-in)
    instance_type: linux_x2
    max_build_duration: 120   # Must exceed the longest expected full-run time
    environment:
      groups:
        - orchestration_credentials   # CM_API_TOKEN, CM_APP_ID, CM_TEAM_ID
    triggering:
      events:
        - push
      branch_patterns:
        - pattern: main
          include: true
      cancel_previous_builds: true
    scripts:
      - name: Run fan-out / fan-in orchestration
        script: python3 ci/orchestrate.py

  # --- HOST APP ---
  # API-triggered only — no triggering block.
  # Receives module artifact URLs as environment variables from the coordinator.
  build-host-app:
    name: Build Host App
    instance_type: mac_mini_m2
    max_build_duration: 120
    environment:
      groups:
        - orchestration_credentials
      vars:
        # Defaults allow manual test runs; coordinator overrides these at runtime
        MODULE_A_ARTIFACT_URL: ""
        MODULE_B_ARTIFACT_URL: ""
        MODULE_GENERIC_ARTIFACT_URL: ""
    scripts:
      - name: Download module artifacts
        script: | 
          mkdir -p artifacts/modules
          for VAR in MODULE_A_ARTIFACT_URL MODULE_B_ARTIFACT_URL MODULE_GENERIC_ARTIFACT_URL; do
            URL="${!VAR}" 
            [ -z "$URL" ] && echo "WARNING: $VAR is empty, skipping" && continue
            FILENAME=$(basename "$URL" | cut -d'?' -f1)
            echo "Downloading $FILENAME..."
            curl -fsSL "$URL" -o "artifacts/modules/$FILENAME"
          done

      - name: Assemble host app
        script: | 
          ./gradlew :host-app:assembleRelease \
            -PmoduleAarDir=artifacts/modules

    artifacts:
      - host-app/build/outputs/**/*.aab
      - host-app/build/outputs/**/*.apk

// package.json (root of your monorepo)
{
  "devDependencies": {
    "nx": "^20.0.0",
    "nx-cloud": "latest"
  }
}

workflows:
  # --- COORDINATOR ---
  # Triggered by git push. Starts agent VMs via the REST API, then submits
  # the task graph to Nx Cloud. Does not execute any build tasks itself.
  # Uses linux_x2 — no mobile toolchain needed for orchestration.
  nx-coordinator:
    name: Nx Cloud Coordinator
    instance_type: linux_x2
    max_build_duration: 120
    environment:
      groups:
        - orchestration_credentials   # CM_API_TOKEN, CM_APP_ID
        - nx_cloud                    # NX_CLOUD_ACCESS_TOKEN
    triggering:
      events:
        - push
      branch_patterns:
        - pattern: main
          include: true
      cancel_previous_builds: true
    scripts:
      - name: Install dependencies
        script: npm ci

      - name: Start Nx Cloud agent VMs
        script: | 
          # Trigger the agent workflow 3 times via the Codemagic REST API.
          # Each agent receives NX_CI_EXECUTION_ID so Nx Cloud can group
          # all four VMs (this coordinator + 3 agents) into one pipeline run.
          # jq is pre-installed on all Codemagic instances.
          for i in 1 2 3; do
            curl -fsSL -X POST https://api.codemagic.io/builds \
              -H "Content-Type: application/json" \
              -H "x-auth-token: $CM_API_TOKEN" \
              --data "$(jq -n \
                --arg appId  "$CM_APP_ID" \
                --arg branch "$CM_BRANCH" \
                --arg execId "$CM_BUILD_ID" \
                --arg token  "$NX_CLOUD_ACCESS_TOKEN" \
                --arg agent  "agent-$i" \
                '{
                  appId: $appId,
                  workflowId: "nx-agent",
                  branch: $branch,
                  environment: {
                    variables: {
                      NX_CI_EXECUTION_ID:    $execId,
                      NX_CLOUD_ACCESS_TOKEN: $token,
                      NX_BRANCH:             $branch,
                      NX_AGENT_NAME:         $agent
                    }
                  }
                }')"
          done

      - name: Register CI run and submit task graph to Nx Cloud
        script: | 
          # Set the same execution ID that was passed to the agents above.
          # This is what Nx Cloud uses to group all VMs into one run.
          export NX_CI_EXECUTION_ID="$CM_BUILD_ID"

          # Tell Nx Cloud we are using manual DTE (we manage our own agent VMs).
          npx nx-cloud start-ci-run --distribute-on="manual"

          # Submit the affected task graph. Nx Cloud distributes tasks to agents.
          # The coordinator blocks here until all tasks complete.
          npx nx affected \
            --target=build \
            --base=origin/main \
            --head=HEAD \
            --parallel=2

      - name: Complete CI run
        script: | 
          export NX_CI_EXECUTION_ID="$CM_BUILD_ID"
          npx nx-cloud complete-ci-run
        # Always runs — releases agents cleanly even if a previous step fails
        ignore_failure: true

  # --- NX CLOUD AGENT ---
  # API-triggered only — no triggering block.
  # Checks out the repo, installs dependencies, then waits for Nx Cloud to
  # assign tasks. NX_CI_EXECUTION_ID is injected at trigger time by the coordinator.
  # Uses mac_mini_m2 so agents can execute both Android and iOS build tasks.
  nx-agent:
    name: Nx Cloud Agent
    instance_type: mac_mini_m2
    max_build_duration: 120
    environment:
      groups:
        - nx_cloud          # NX_CLOUD_ACCESS_TOKEN (fallback; coordinator also injects it)
      vars:
        NX_CI_EXECUTION_ID: ""    # Overridden at trigger time by the coordinator
        NX_AGENT_NAME: "agent"    # Overridden per-agent by the coordinator
    cache:
      cache_paths:
        - node_modules        # Warm cache drastically reduces agent cold-start time
        - ~/.nx/cache         # Nx local computation cache
    scripts:
      - name: Install dependencies
        script: npm ci

      - name: Wait for Nx Cloud task assignments
        script: | 
          # This command blocks until Nx Cloud sends a stop signal,
          # which happens automatically when the coordinator's run completes.
          npx nx-cloud start-agent

workflows:
  nx-affected:
    name: Nx Affected Build (single VM)
    instance_type: mac_mini_m2
    max_build_duration: 120
    environment:
      groups:
        - nx_cloud          # NX_CLOUD_ACCESS_TOKEN — optional, enables remote cache
    cache:
      cache_paths:
        - node_modules
        - ~/.nx/cache
    triggering:
      events:
        - push
        - pull_request
      branch_patterns:
        - pattern: main
          include: true
      cancel_previous_builds: true
    scripts:
      - name: Install dependencies
        script: npm ci

      - name: Build affected modules
        script: | 
          # CM_PULL_REQUEST_BASE_BRANCH is set by Codemagic on PR builds.
          # Fall back to origin/main for push builds.
          BASE_REF="${CM_PULL_REQUEST_BASE_BRANCH:-origin/main}"

          npx nx affected \
            --target=build \
            --base="$BASE_REF" \
            --head=HEAD \
            --parallel=4 \
            --output-style=stream

      - name: Assemble host app
        script: npx nx run host-app:assemble

    artifacts:
      - host-app/dist/**/*.aab
      - host-app/dist/**/*.apk

workflows:
  turbo-build:
    name: Turborepo Build (single VM)
    instance_type: mac_mini_m2
    max_build_duration: 120
    environment:
      vars:
        # Vercel remote cache credentials — optional, enables cross-build caching.
        # Remove if using local cache only.
        TURBO_TOKEN: $TURBO_TOKEN
        TURBO_TEAM: $TURBO_TEAM
    cache:
      cache_paths:
        - node_modules
        - .turbo
    triggering:
      events:
        - push
        - pull_request
      branch_patterns:
        - pattern: main
          include: true
      cancel_previous_builds: true
    scripts:
      - name: Install dependencies
        script: npm ci

      - name: Build changed packages and their dependents
        script: npx turbo run build --affected

      - name: Assemble host app
        script: npx turbo run assemble --filter=host-app

    artifacts:
      - host-app/dist/**/*.aab
      - host-app/dist/**/*.apk