@khester/create-dynamics-app 1.0.8 → 1.1.0

package/templates/dynamics-365-starter/deployment/pipelines/README.md

@@ -0,0 +1,375 @@
+# CI/CD Pipelines - Cross-Platform Team Support
+
+This directory contains CI/CD pipeline configurations that support mixed Windows/Mac development
+teams working on Dynamics 365 projects.
+
+## Overview
+
+The pipeline configurations demonstrate how to create robust, cross-platform CI/CD workflows that
+allow Windows and Mac developers to work seamlessly on the same project while using their preferred
+platform and tooling.
+
+## Pipeline Files
+
+### 🔷 Azure DevOps Pipeline
+
+**File**: `azure-pipelines.yml`
+
+- **Build**: Linux agent (ubuntu-latest) for optimal performance
+- **Dev Deploy**: Linux + Bash scripts (Mac developer experience)
+- **Test Deploy**: Windows + PowerShell scripts (enterprise validation)
+- **Prod Deploy**: Linux + Bash scripts (production stability)
+
+```yaml
+# Example stage configuration
+- stage: DeployDev
+  jobs:
+    - deployment: DeployToDev
+      pool:
+        vmImage: 'ubuntu-latest' # Linux for Bash scripts
+      strategy:
+        runOnce:
+          deploy:
+            steps:
+              - bash: ./deployment/scripts/deploy.sh dev --verbose
+```
+
+### 🟢 GitHub Actions Workflow
+
+**File**: `github-actions.yml`
+
+- **Build**: Ubuntu runner for speed and consistency
+- **Dev Deploy**: Ubuntu + Bash (Mac compatibility)
+- **Test Deploy**: Windows + PowerShell (Windows compatibility)
+- **Prod Deploy**: Flexible platform choice via workflow dispatch
+
+```yaml
+# Example job configuration
+deploy-dev:
+  runs-on: ubuntu-latest # Linux for Bash scripts
+  steps:
+    - name: Deploy to Development
+      run: ./deployment/scripts/deploy.sh dev --verbose
+```
+
+### 🔵 Jenkins Pipeline
+
+**File**: `jenkins.groovy`
+
+- **Build**: Linux agents for optimal build performance
+- **Dev Deploy**: Linux + Bash scripts
+- **Test Deploy**: Windows + PowerShell scripts
+- **Prod Deploy**: Manual platform selection with approval gates
+
+```groovy
+// Example stage configuration
+stage('Deploy to Development') {
+    agent { label 'linux && docker' }
+    steps {
+        sh './deployment/scripts/deploy.sh dev --verbose'
+    }
+}
+```
+
+## Cross-Platform Strategy
+
+### 🎯 Design Principles
+
+1. **Platform Optimization**: Use the best platform for each stage
+   - **Linux**: Build performance, Mac developer experience
+   - **Windows**: Enterprise PowerShell workflows, Windows compatibility
+
+2. **Team Compatibility**: Support both development environments
+   - **Windows Developers**: PowerShell scripts locally + Windows CI/CD stages
+   - **Mac Developers**: Bash scripts locally + Linux CI/CD stages
+
+3. **Deployment Consistency**: Identical results regardless of platform
+   - Same build artifacts
+   - Same configuration files
+   - Same deployment outcomes
+
+### 📋 Platform Selection Matrix
+
+| Stage           | Platform | Script Type       | Rationale                                          |
+| --------------- | -------- | ----------------- | -------------------------------------------------- |
+| **Build**       | Linux    | npm/Node.js       | Fastest performance, consistent environment        |
+| **Dev Deploy**  | Linux    | Bash (.sh)        | Mac developer local experience                     |
+| **Test Deploy** | Windows  | PowerShell (.ps1) | Enterprise validation, Windows workflows           |
+| **Prod Deploy** | Flexible | User choice       | Allows team preference or environment requirements |
+
+## Team Member Experience
+
+### 🖥️ Windows Developers
+
+**Local Development**:
+
+```powershell
+# Use PowerShell scripts locally
+.\deployment\scripts\deploy.ps1 -Environment dev
+.\deployment\scripts\health-check.ps1 -Environment dev
+
+# Follow Windows-specific guide
+Get-Content deployment\QUICKSTART-WINDOWS.md
+
+# Run team onboarding
+.\deployment\scripts\team-onboarding.ps1
+```
+
+**CI/CD Experience**:
+
+- Build stage runs on Linux (faster)
+- Test deployment uses Windows runners with PowerShell
+- Production deployment can use Windows if preferred
+- All pipeline results match local PowerShell deployment results
+
+### 🍎 Mac Developers
+
+**Local Development**:
+
+```bash
+# Use Bash scripts locally
+./deployment/scripts/deploy.sh dev
+./deployment/scripts/health-check.sh dev
+
+# Follow Mac-specific guide
+open deployment/QUICKSTART-MAC.md
+
+# Run team onboarding
+./deployment/scripts/team-onboarding.sh
+```
+
+**CI/CD Experience**:
+
+- Build stage runs on Linux (compatible)
+- Development deployment uses Linux runners with Bash
+- Production deployment uses Linux by default
+- All pipeline results match local Bash deployment results
+
+## Configuration Examples
+
+### Azure DevOps Variable Groups
+
+Create these variable groups in Azure DevOps:
+
+```yaml
+# dynamics-365-dev-secrets
+D365_DEV_CLIENT_ID: 'your-dev-client-id'
+D365_DEV_CLIENT_SECRET: 'your-dev-client-secret'
+D365_DEV_TENANT_ID: 'your-dev-tenant-id'
+D365_DEV_ORG_URL: 'https://yourdev.crm.dynamics.com'
+
+# dynamics-365-test-secrets
+D365_TEST_CLIENT_ID: 'your-test-client-id'
+D365_TEST_CLIENT_SECRET: 'your-test-client-secret'
+D365_TEST_TENANT_ID: 'your-test-tenant-id'
+D365_TEST_ORG_URL: 'https://yourtest.crm.dynamics.com'
+```
+
+### GitHub Actions Secrets
+
+Add these secrets to your GitHub repository:
+
+```yaml
+# Development environment
+D365_DEV_CLIENT_ID
+D365_DEV_CLIENT_SECRET
+D365_DEV_TENANT_ID
+
+# Test environment
+D365_TEST_CLIENT_ID
+D365_TEST_CLIENT_SECRET
+D365_TEST_TENANT_ID
+
+# Production environment
+D365_PROD_CLIENT_ID
+D365_PROD_CLIENT_SECRET
+D365_PROD_TENANT_ID
+```
+
+### Jenkins Credentials
+
+Create these credential entries in Jenkins:
+
+```groovy
+// Username/Password credentials
+d365-dev-credentials: [username: client-id, password: client-secret]
+d365-test-credentials: [username: client-id, password: client-secret]
+d365-prod-credentials: [username: client-id, password: client-secret]
+```
+
+## Platform-Specific Features
+
+### Azure DevOps Highlights
+
+- **Mixed Agents**: Linux for builds, Windows for PowerShell validation
+- **Variable Groups**: Centralized secret management
+- **Environment Gates**: Manual approvals for production
+- **Cross-Platform Validation**: Parallel validation on both platforms
+
+### GitHub Actions Highlights
+
+- **Workflow Dispatch**: Manual triggers with platform selection
+- **Matrix Builds**: Cross-platform validation in pull requests
+- **Environment Protection**: Branch protection and approval workflows
+- **Platform Detection**: Automatic runner selection based on strategy
+
+### Jenkins Highlights
+
+- **Agent Labels**: Flexible agent selection (linux, windows, docker)
+- **Manual Approval**: Production deployment approval with platform choice
+- **Parallel Validation**: Cross-platform validation stages
+- **Artifact Management**: Centralized build artifact sharing
+
+## Troubleshooting Cross-Platform Issues
+
+### Common Platform-Specific Problems
+
+#### Windows PowerShell Issues
+
+```powershell
+# Module installation problems
+Install-Module -Name Microsoft.PowerApps.Administration.PowerShell -Force -AllowClobber -Scope CurrentUser
+
+# Execution policy issues
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+# Path separator issues (use either)
+.\deployment\scripts\deploy.ps1    # Windows style
+./deployment/scripts/deploy.ps1    # Cross-platform style
+```
+
+#### Linux/Mac Bash Issues
+
+```bash
+# Script permissions
+chmod +x deployment/scripts/*.sh
+
+# Missing dependencies
+# Ubuntu/Debian:
+sudo apt-get install jq curl nodejs npm
+
+# macOS:
+brew install jq curl node npm
+
+# Path issues (always use forward slashes)
+./deployment/scripts/deploy.sh
+```
+
+### Pipeline-Specific Debugging
+
+#### Azure DevOps
+
+```yaml
+# Enable verbose logging
+- bash: ./deployment/scripts/deploy.sh dev --verbose
+  displayName: 'Deploy with verbose output'
+
+# Platform detection
+- bash: |
+    echo "Runner OS: $(Agent.OS)"
+    echo "Agent Name: $(Agent.Name)"
+    uname -a
+  displayName: 'Show platform information'
+```
+
+#### GitHub Actions
+
+```yaml
+# Debug runner environment
+- name: Debug Platform
+  run: |
+    echo "Runner OS: ${{ runner.os }}"
+    echo "Runner Name: ${{ runner.name }}"
+    uname -a || systeminfo
+```
+
+#### Jenkins
+
+```groovy
+// Debug agent information
+sh '''
+    echo "Node Name: ${NODE_NAME}"
+    echo "Agent OS: $(uname -a || systeminfo)"
+    echo "Available Scripts:"
+    ls -la deployment/scripts/ || dir deployment\\scripts\\
+'''
+```
+
+## Best Practices
+
+### 1. Script Compatibility
+
+- ✅ Maintain parallel PowerShell (.ps1) and Bash (.sh) scripts
+- ✅ Use identical command-line interfaces where possible
+- ✅ Share JSON configuration files between platforms
+- ✅ Test both script types produce identical results
+
+### 2. Pipeline Strategy
+
+- ✅ Use Linux for build performance
+- ✅ Use Windows for PowerShell module testing
+- ✅ Provide platform choice for production deployments
+- ✅ Include cross-platform validation for pull requests
+
+### 3. Team Onboarding
+
+- ✅ Provide platform-specific quick start guides
+- ✅ Include team onboarding scripts for both platforms
+- ✅ Document command equivalents in team documentation
+- ✅ Set up platform-specific development environments
+
+### 4. Error Handling
+
+- ✅ Include platform detection in error messages
+- ✅ Provide platform-specific troubleshooting steps
+- ✅ Log platform information in deployment logs
+- ✅ Include rollback procedures for both platforms
+
+## Command Equivalents Reference
+
+| Task                | Windows PowerShell                                        | Mac/Linux Bash                     | Result                  |
+| ------------------- | --------------------------------------------------------- | ---------------------------------- | ----------------------- |
+| **Deploy to Dev**   | `.\deploy.ps1 -Environment dev`                           | `./deploy.sh dev`                  | Identical deployment    |
+| **Health Check**    | `.\health-check.ps1 -Environment prod`                    | `./health-check.sh prod`           | Same validation         |
+| **Rollback**        | `.\rollback.ps1 -Environment prod -BackupFile backup.zip` | `./rollback.sh prod backup.tar.gz` | Same rollback           |
+| **Team Onboarding** | `.\team-onboarding.ps1`                                   | `./team-onboarding.sh`             | Platform-specific setup |
+
+## Getting Started
+
+### For New Projects
+
+1. **Choose Your Pipeline**: Select Azure DevOps, GitHub Actions, or Jenkins
+2. **Copy Configuration**: Use the appropriate pipeline file as a starting point
+3. **Configure Secrets**: Set up environment-specific credentials
+4. **Test Cross-Platform**: Run validation on both Windows and Linux agents
+5. **Document Team Process**: Share platform-specific guides with your team
+
+### For Existing Projects
+
+1. **Assess Current Setup**: Determine current platform dependencies
+2. **Create Parallel Scripts**: Add missing PowerShell or Bash scripts
+3. **Update Pipeline**: Modify existing pipeline for cross-platform support
+4. **Validate Compatibility**: Test deployment results across platforms
+5. **Train Team**: Provide platform-specific training and documentation
+
+## Support and Troubleshooting
+
+### Documentation Resources
+
+- **Windows Setup**: `../QUICKSTART-WINDOWS.md`
+- **Mac Setup**: `../QUICKSTART-MAC.md`
+- **Deployment Guide**: `../README.md`
+- **Team Standards**: `../../docs/team-standards/`
+
+### Getting Help
+
+- Check platform-specific logs in `../logs/`
+- Review deployment scripts in `../scripts/`
+- Consult team onboarding scripts for environment setup
+- Contact DevOps team with platform and error details
+
+---
+
+This cross-platform CI/CD approach ensures that Windows and Mac developers can work together
+seamlessly while leveraging the strengths of each platform for optimal build and deployment
+performance.

package/templates/dynamics-365-starter/deployment/pipelines/azure-pipelines.yml

@@ -0,0 +1,330 @@
+# Azure DevOps Pipeline - Dual Platform Support
+# Supports both Windows and Linux agents for mixed development teams
+
+trigger:
+  branches:
+    include:
+      - main
+      - develop
+      - feature/*
+  paths:
+    exclude:
+      - docs/*
+      - "*.md"
+
+pr:
+  branches:
+    include:
+      - main
+      - develop
+
+variables:
+  - group: dynamics-365-variables # Variable group with environment configs
+  - name: node.version
+    value: "18.x"
+  - name: npm.cache
+    value: $(Pipeline.Workspace)/.npm
+
+stages:
+  # Build Stage - Run on Linux for faster execution
+  - stage: Build
+    displayName: "Build Application"
+    jobs:
+      - job: BuildJob
+        displayName: "Build and Test"
+        pool:
+          vmImage: "ubuntu-latest" # Linux agent for faster builds
+        steps:
+          - task: NodeTool@0
+            displayName: "Install Node.js"
+            inputs:
+              versionSpec: $(node.version)
+
+          - task: Cache@2
+            displayName: "Cache npm dependencies"
+            inputs:
+              key: 'npm | "$(Agent.OS)" | package-lock.json'
+              restoreKeys: |
+                npm | "$(Agent.OS)"
+              path: $(npm.cache)
+
+          - script: |
+              npm config set cache $(npm.cache)
+              npm ci
+            displayName: "Install dependencies"
+
+          - script: npm run lint
+            displayName: "Run linting"
+
+          - script: npm run typecheck
+            displayName: "TypeScript validation"
+
+          - script: npm run test
+            displayName: "Run unit tests"
+
+          - script: npm run build:prod
+            displayName: "Build production bundle"
+
+          - task: PublishTestResults@2
+            displayName: "Publish test results"
+            inputs:
+              testResultsFormat: "JUnit"
+              testResultsFiles: "test-results.xml"
+              mergeTestResults: true
+            condition: succeededOrFailed()
+
+          - task: PublishCodeCoverageResults@1
+            displayName: "Publish code coverage"
+            inputs:
+              codeCoverageTool: "Cobertura"
+              summaryFileLocation: "coverage/cobertura-coverage.xml"
+              reportDirectory: "coverage"
+            condition: succeededOrFailed()
+
+          - task: PublishBuildArtifacts@1
+            displayName: "Publish build artifacts"
+            inputs:
+              PathtoPublish: "dist"
+              ArtifactName: "build-artifacts"
+
+          - task: PublishBuildArtifacts@1
+            displayName: "Publish deployment scripts"
+            inputs:
+              PathtoPublish: "deployment"
+              ArtifactName: "deployment-scripts"
+
+  # Development Deployment - Linux Agent with Bash
+  - stage: DeployDev
+    displayName: "Deploy to Development"
+    dependsOn: Build
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/develop'))
+    jobs:
+      - deployment: DeployToDev
+        displayName: "Deploy to Development Environment"
+        pool:
+          vmImage: "ubuntu-latest" # Linux agent for Bash scripts
+        environment: "Dynamics365-Dev"
+        variables:
+          - group: dynamics-365-dev-secrets
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - download: current
+                  artifact: build-artifacts
+                  displayName: "Download build artifacts"
+
+                - download: current
+                  artifact: deployment-scripts
+                  displayName: "Download deployment scripts"
+
+                - task: CopyFiles@2
+                  displayName: "Copy build artifacts"
+                  inputs:
+                    SourceFolder: "$(Pipeline.Workspace)/build-artifacts"
+                    TargetFolder: "$(System.DefaultWorkingDirectory)/dist"
+
+                - task: CopyFiles@2
+                  displayName: "Copy deployment scripts"
+                  inputs:
+                    SourceFolder: "$(Pipeline.Workspace)/deployment-scripts"
+                    TargetFolder: "$(System.DefaultWorkingDirectory)/deployment"
+
+                - bash: |
+                    # Make scripts executable
+                    chmod +x deployment/scripts/*.sh
+
+                    # Set up environment variables from Azure DevOps variable group
+                    export D365_CLIENT_ID="$(D365_DEV_CLIENT_ID)"
+                    export D365_CLIENT_SECRET="$(D365_DEV_CLIENT_SECRET)"
+                    export D365_TENANT_ID="$(D365_DEV_TENANT_ID)"
+                    export D365_ORG_URL="$(D365_DEV_ORG_URL)"
+
+                    # Run deployment using Bash script
+                    ./deployment/scripts/deploy.sh dev --verbose
+                  displayName: "Deploy to Development (Bash)"
+                  env:
+                    D365_DEV_CLIENT_ID: $(D365_DEV_CLIENT_ID)
+                    D365_DEV_CLIENT_SECRET: $(D365_DEV_CLIENT_SECRET)
+                    D365_DEV_TENANT_ID: $(D365_DEV_TENANT_ID)
+                    D365_DEV_ORG_URL: $(D365_DEV_ORG_URL)
+
+  # Test Deployment - Windows Agent with PowerShell
+  - stage: DeployTest
+    displayName: "Deploy to Test"
+    dependsOn: Build
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    jobs:
+      - deployment: DeployToTest
+        displayName: "Deploy to Test Environment"
+        pool:
+          vmImage: "windows-latest" # Windows agent for PowerShell scripts
+        environment: "Dynamics365-Test"
+        variables:
+          - group: dynamics-365-test-secrets
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - download: current
+                  artifact: build-artifacts
+                  displayName: "Download build artifacts"
+
+                - download: current
+                  artifact: deployment-scripts
+                  displayName: "Download deployment scripts"
+
+                - task: CopyFiles@2
+                  displayName: "Copy build artifacts"
+                  inputs:
+                    SourceFolder: "$(Pipeline.Workspace)/build-artifacts"
+                    TargetFolder: "$(System.DefaultWorkingDirectory)/dist"
+
+                - task: CopyFiles@2
+                  displayName: "Copy deployment scripts"
+                  inputs:
+                    SourceFolder: "$(Pipeline.Workspace)/deployment-scripts"
+                    TargetFolder: "$(System.DefaultWorkingDirectory)/deployment"
+
+                - task: PowerShell@2
+                  displayName: "Install PowerShell modules"
+                  inputs:
+                    targetType: "inline"
+                    script: |
+                      Install-Module -Name Microsoft.PowerApps.Administration.PowerShell -Force -AllowClobber
+                      Install-Module -Name Microsoft.PowerApps.PowerShell -Force -AllowClobber
+
+                - task: PowerShell@2
+                  displayName: "Deploy to Test (PowerShell)"
+                  inputs:
+                    filePath: "$(System.DefaultWorkingDirectory)/deployment/scripts/deploy.ps1"
+                    arguments: "-Environment test -Verbose"
+                  env:
+                    D365_TEST_CLIENT_ID: $(D365_TEST_CLIENT_ID)
+                    D365_TEST_CLIENT_SECRET: $(D365_TEST_CLIENT_SECRET)
+                    D365_TEST_TENANT_ID: $(D365_TEST_TENANT_ID)
+                    D365_TEST_ORG_URL: $(D365_TEST_ORG_URL)
+
+  # Production Deployment - Support both platforms with approval gates
+  - stage: DeployProd
+    displayName: "Deploy to Production"
+    dependsOn: [DeployTest]
+    condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
+    jobs:
+      - deployment: DeployToProd
+        displayName: "Deploy to Production Environment"
+        pool:
+          # Allow either Windows or Linux agents based on availability
+          vmImage: "ubuntu-latest" # Default to Linux for consistency
+        environment: "Dynamics365-Production"
+        variables:
+          - group: dynamics-365-prod-secrets
+        strategy:
+          runOnce:
+            deploy:
+              steps:
+                - download: current
+                  artifact: build-artifacts
+                  displayName: "Download build artifacts"
+
+                - download: current
+                  artifact: deployment-scripts
+                  displayName: "Download deployment scripts"
+
+                - task: CopyFiles@2
+                  displayName: "Copy build artifacts"
+                  inputs:
+                    SourceFolder: "$(Pipeline.Workspace)/build-artifacts"
+                    TargetFolder: "$(System.DefaultWorkingDirectory)/dist"
+
+                - task: CopyFiles@2
+                  displayName: "Copy deployment scripts"
+                  inputs:
+                    SourceFolder: "$(Pipeline.Workspace)/deployment-scripts"
+                    TargetFolder: "$(System.DefaultWorkingDirectory)/deployment"
+
+                # Production deployment with enhanced validation
+                - bash: |
+                    # Make scripts executable
+                    chmod +x deployment/scripts/*.sh
+
+                    # Set up environment variables
+                    export D365_CLIENT_ID="$(D365_PROD_CLIENT_ID)"
+                    export D365_CLIENT_SECRET="$(D365_PROD_CLIENT_SECRET)"
+                    export D365_TENANT_ID="$(D365_PROD_TENANT_ID)"
+                    export D365_ORG_URL="$(D365_PROD_ORG_URL)"
+
+                    echo "Starting production deployment..."
+
+                    # Run pre-deployment validation
+                    ./deployment/scripts/validate-setup.sh
+
+                    # Create backup before deployment
+                    ./deployment/scripts/backup.sh prod
+
+                    # Deploy with backup enabled
+                    ./deployment/scripts/deploy.sh prod --verbose
+
+                    # Post-deployment health check
+                    ./deployment/scripts/health-check.sh prod
+
+                    echo "Production deployment completed successfully"
+                  displayName: "Deploy to Production with Validation"
+                  env:
+                    D365_PROD_CLIENT_ID: $(D365_PROD_CLIENT_ID)
+                    D365_PROD_CLIENT_SECRET: $(D365_PROD_CLIENT_SECRET)
+                    D365_PROD_TENANT_ID: $(D365_PROD_TENANT_ID)
+                    D365_PROD_ORG_URL: $(D365_PROD_ORG_URL)
+
+                # Rollback capability
+                - bash: |
+                    echo "##vso[task.setvariable variable=BACKUP_FILE;isOutput=true]$(ls deployment/backups/backup-prod-*.tar.gz | tail -n1)"
+                  displayName: "Set backup file variable"
+                  name: backupInfo
+                  condition: succeededOrFailed()
+
+  # Cross-Platform Development Support Documentation
+  - stage: Documentation
+    displayName: "Platform Compatibility Info"
+    dependsOn: Build
+    condition: always()
+    jobs:
+      - job: PlatformInfo
+        displayName: "Cross-Platform Development Information"
+        pool:
+          vmImage: "ubuntu-latest"
+        steps:
+          - script: |
+              echo "=== CROSS-PLATFORM DEVELOPMENT TEAM SUPPORT ==="
+              echo ""
+              echo "This pipeline supports mixed Windows/Mac development teams:"
+              echo ""
+              echo "🖥️  WINDOWS DEVELOPERS:"
+              echo "   • Use PowerShell scripts: deployment/scripts/*.ps1"
+              echo "   • Follow guide: deployment/QUICKSTART-WINDOWS.md"
+              echo "   • Run: deployment/scripts/team-onboarding.ps1"
+              echo ""
+              echo "🍎 MAC/LINUX DEVELOPERS:"
+              echo "   • Use Bash scripts: deployment/scripts/*.sh"
+              echo "   • Follow guide: deployment/QUICKSTART-MAC.md"
+              echo "   • Run: deployment/scripts/team-onboarding.sh"
+              echo ""
+              echo "✅ COMPATIBILITY GUARANTEE:"
+              echo "   • Same deployment results across all platforms"
+              echo "   • Shared JSON configuration files"
+              echo "   • Identical entity generation and builds"
+              echo "   • Compatible log formats for troubleshooting"
+              echo ""
+              echo "🔧 PIPELINE STRATEGY:"
+              echo "   • Build: Linux agent (faster performance)"
+              echo "   • Dev Deploy: Linux + Bash (developer testing)"
+              echo "   • Test Deploy: Windows + PowerShell (integration testing)"
+              echo "   • Prod Deploy: Linux + Bash (production stability)"
+              echo ""
+              echo "Command Equivalents:"
+              echo "Windows:  .\\deploy.ps1 -Environment dev"
+              echo "Mac:      ./deploy.sh dev"
+              echo "Result:   Identical deployment to D365"
+              echo ""
+              echo "=== END PLATFORM INFO ==="
+            displayName: "Show Platform Compatibility Information"