Guide

Gérez et contrôlez l'accès aux Préférences Système sur vos appareils Roundfleet avec une gestion complète des panneaux de préférences, des contrôles de restriction utilisateur et des solutions de configuration d'entreprise. Ce tutoriel couvre le masquage, la désactivation et le contrôle des Préférences Système pour une sécurité et conformité renforcées.

Comprendre la Gestion des Préférences Système

Les Préférences Système sur macOS fournissent l'accès aux paramètres de configuration système :

• Panneaux de Préférences - Modules de configuration individuels (Réseau, Sécurité, Utilisateurs, etc.)
• Identifiants de Bundle - Identifiants uniques pour chaque panneau de préférences
• Masqué vs Désactivé - Différents niveaux de restriction d'accès
• Contrôle d'Entreprise - Gestion centralisée de l'accès utilisateur aux paramètres système

Cas d'Usage d'Entreprise

La gestion des Préférences Système bénéficie aux environnements d'entreprise :

• Durcissement de Sécurité - Empêcher les modifications de configuration non autorisées
• Conformité - Assurer que les appareils respectent les exigences réglementaires
• Expérience Utilisateur - Simplifier les interfaces en masquant les options non pertinentes
• Contrôle Administratif - Centraliser la gestion de configuration
• Protection des Données - Restreindre l'accès aux paramètres système sensibles

Contrôle de Base des Préférences Système

Masquer le Panneau Profils

#!/bin/bash

# Masquer le panneau Profils des Préférences Système
hide_profiles_pane() {
    echo "=== Masquage du Panneau Profils ==="
    
    # Vérifier la version macOS (le masquage nécessite macOS 13.0+)
    local macos_version=$(sw_vers -productVersion | cut -d. -f1)
    if [[ $macos_version -lt 13 ]]; then
        echo "Avertissement : Le masquage des panneaux nécessite macOS 13.0 ou ultérieur"
        echo "Version actuelle : $(sw_vers -productVersion)"
        echo "Utilisation de la désactivation au lieu du masquage..."
        disable_profiles_pane
        return
    fi
    
    # Masquer le panneau Profils
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        HiddenPreferencePanes -array "com.apple.preferences.configurationprofiles"
    
    if [[ $? -eq 0 ]]; then
        echo "✓ Panneau Profils masqué avec succès"
        echo "Les utilisateurs ne verront plus le panneau Profils dans les Préférences Système"
    else
        echo "✗ Échec du masquage du panneau Profils"
        return 1
    fi
}

# Désactiver le panneau Profils (alternative pour macOS plus ancien)
disable_profiles_pane() {
    echo "=== Désactivation du Panneau Profils ==="
    
    # Désactiver le panneau Profils (fonctionne sur macOS 10.2+)
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "com.apple.preferences.configurationprofiles"
    
    if [[ $? -eq 0 ]]; then
        echo "✓ Panneau Profils désactivé avec succès"
        echo "Le panneau Profils apparaîtra grisé dans les Préférences Système"
    else
        echo "✗ Échec de la désactivation du panneau Profils"
        return 1
    fi
}

# Usage
hide_profiles_pane

Restaurer/Réactiver le Panneau Profils

#!/bin/bash

# Restaurer l'accès au panneau Profils
restore_profiles_pane() {
    echo "=== Restauration de l'Accès au Panneau Profils ==="
    
    # Supprimer des panneaux masqués
    local hidden_panes=$(defaults read "/Library/Preferences/com.apple.systempreferences" HiddenPreferencePanes 2>/dev/null)
    if [[ -n "$hidden_panes" ]]; then
        echo "Suppression des panneaux masqués..."
        defaults delete "/Library/Preferences/com.apple.systempreferences" HiddenPreferencePanes 2>/dev/null
    fi
    
    # Supprimer des panneaux désactivés
    local disabled_panes=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null)
    if [[ -n "$disabled_panes" ]]; then
        echo "Suppression des panneaux désactivés..."
        defaults delete "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null
    fi
    
    echo "✓ Accès au panneau Profils restauré"
    echo "Les utilisateurs peuvent maintenant accéder au panneau Profils dans les Préférences Système"
}

# Usage
restore_profiles_pane

Gestion de Plusieurs Panneaux de Préférences

#!/bin/bash

# Gérer plusieurs panneaux de préférences simultanément
manage_multiple_panes() {
    local action="${1:-hide}"  # hide, disable, ou restore
    local panes=("${@:2}")    # Tableau d'identifiants de panneaux
    
    if [[ ${#panes[@]} -eq 0 ]]; then
        echo "Usage : manage_multiple_panes [hide|disable|restore] <panneau1> [panneau2] ..."
        echo "Exemple : manage_multiple_panes hide profiles bluetooth network"
        return 1
    fi
    
    echo "=== Gestion de Plusieurs Panneaux de Préférences ==="
    echo "Action : $action"
    echo "Panneaux : ${panes[*]}"
    echo ""
    
    # Convertir les noms conviviaux en identifiants de bundle
    local bundle_ids=()
    for pane in "${panes[@]}"; do
        local bundle_id=$(get_bundle_identifier "$pane")
        if [[ -n "$bundle_id" ]]; then
            bundle_ids+=("$bundle_id")
            echo "✓ $pane -> $bundle_id"
        else
            echo "✗ Panneau inconnu : $pane"
        fi
    done
    
    if [[ ${#bundle_ids[@]} -eq 0 ]]; then
        echo "Aucun panneau valide spécifié"
        return 1
    fi
    
    # Appliquer l'action
    case "$action" in
        "hide")
            defaults write "/Library/Preferences/com.apple.systempreferences" \
                HiddenPreferencePanes -array "${bundle_ids[@]}"
            echo "✓ Panneaux masqués avec succès"
            ;;
        "disable")
            defaults write "/Library/Preferences/com.apple.systempreferences" \
                DisabledPreferencePanes -array "${bundle_ids[@]}"
            echo "✓ Panneaux désactivés avec succès"
            ;;
        "restore")
            defaults delete "/Library/Preferences/com.apple.systempreferences" HiddenPreferencePanes 2>/dev/null
            defaults delete "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null
            echo "✓ Tous les panneaux restaurés"
            ;;
        *)
            echo "Action invalide : $action"
            return 1
            ;;
    esac
}

# Convertir les noms conviviaux en identifiants de bundle
get_bundle_identifier() {
    local pane_name="$1"
    
    case "$pane_name" in
        "profiles") echo "com.apple.preferences.configurationprofiles" ;;
        "bluetooth") echo "com.apple.preferences.Bluetooth" ;;
        "network") echo "com.apple.preference.network" ;;
        "security") echo "com.apple.preference.security" ;;
        "users") echo "com.apple.preferences.users" ;;
        "sharing") echo "com.apple.preferences.sharing" ;;
        "timemachine") echo "com.apple.prefs.backup" ;;
        "energy") echo "com.apple.preference.energysaver" ;;
        "displays") echo "com.apple.preference.displays" ;;
        "sound") echo "com.apple.preference.sound" ;;
        "keyboard") echo "com.apple.preference.keyboard" ;;
        "mouse") echo "com.apple.preference.mouse" ;;
        "trackpad") echo "com.apple.preference.trackpad" ;;
        "printers") echo "com.apple.preference.printfax" ;;
        "software_update") echo "com.apple.preferences.softwareupdate" ;;
        "date_time") echo "com.apple.preference.datetime" ;;
        "startup_disk") echo "com.apple.preference.startupdisk" ;;
        "accessibility") echo "com.apple.preference.universalaccess" ;;
        "screen_time") echo "com.apple.preference.screentime" ;;
        "extensions") echo "com.apple.preferences.extensions" ;;
        "spotlight") echo "com.apple.preference.spotlight" ;;
        "language_region") echo "com.apple.Localization" ;;
        "desktop_screensaver") echo "com.apple.preference.desktopscreeneffect" ;;
        "dock") echo "com.apple.preference.dock" ;;
        "mission_control") echo "com.apple.preference.expose" ;;
        "notifications") echo "com.apple.preference.notifications" ;;
        "internet_accounts") echo "com.apple.preferences.internetaccounts" ;;
        "wallet_apple_pay") echo "com.apple.preferences.wallet" ;;
        "siri") echo "com.apple.preference.speech" ;;
        "touch_id") echo "com.apple.preferences.password" ;;
        *) echo "" ;;
    esac
}

# Exemples d'utilisation
# manage_multiple_panes hide profiles bluetooth network
# manage_multiple_panes disable security users sharing
# manage_multiple_panes restore

Gestion Avancée des Préférences Système

Gestion des Préférences Basée sur les Politiques

#!/bin/bash

# Gestion des préférences système basée sur les politiques
apply_preference_policy() {
    local policy_name="${1:-standard_office}"
    local user_role="${2:-standard_user}"
    
    echo "=== Application de Politique de Préférences ==="
    echo "Politique : $policy_name"
    echo "Rôle Utilisateur : $user_role"
    echo ""
    
    # Définir les politiques
    case "$policy_name" in
        "kiosk_mode")
            apply_kiosk_policy "$user_role"
            ;;
        "locked_down")
            apply_locked_down_policy "$user_role"
            ;;
        "standard_office")
            apply_standard_office_policy "$user_role"
            ;;
        "developer_workstation")
            apply_developer_policy "$user_role"
            ;;
        "educational")
            apply_educational_policy "$user_role"
            ;;
        "healthcare")
            apply_healthcare_policy "$user_role"
            ;;
        "financial")
            apply_financial_policy "$user_role"
            ;;
        "public_terminal")
            apply_public_terminal_policy "$user_role"
            ;;
        "executive")
            apply_executive_policy "$user_role"
            ;;
        "contractor")
            apply_contractor_policy "$user_role"
            ;;
        *)
            echo "Politique inconnue : $policy_name"
            return 1
            ;;
    esac
}

# Politique mode kiosque (restrictions maximales)
apply_kiosk_policy() {
    echo "Application de la politique mode kiosque..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preferences.sharing"
        "com.apple.preference.network"
        "com.apple.prefs.backup"
        "com.apple.preferences.softwareupdate"
        "com.apple.preference.datetime"
        "com.apple.preference.startupdisk"
        "com.apple.preferences.extensions"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        HiddenPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique kiosque appliquée - la plupart des préférences masquées"
}

# Politique verrouillée (haute sécurité)
apply_locked_down_policy() {
    echo "Application de la politique verrouillée..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preferences.sharing"
        "com.apple.prefs.backup"
        "com.apple.preferences.softwareupdate"
        "com.apple.preference.startupdisk"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique verrouillée appliquée - panneaux sensibles à la sécurité désactivés"
}

# Politique bureau standard (restrictions modérées)
apply_standard_office_policy() {
    echo "Application de la politique bureau standard..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preferences.sharing"
        "com.apple.preference.startupdisk"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique bureau standard appliquée - restrictions minimales"
}

# Politique poste de développeur (restrictions minimales)
apply_developer_policy() {
    echo "Application de la politique poste de développeur..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique développeur appliquée - seule la gestion de profils restreinte"
}

# Politique éducative (restrictions appropriées aux étudiants)
apply_educational_policy() {
    echo "Application de la politique éducative..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preferences.sharing"
        "com.apple.preferences.softwareupdate"
        "com.apple.preference.startupdisk"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        HiddenPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique éducative appliquée - configuration sécurisée pour étudiants"
}

# Politique santé (axée sur la conformité HIPAA)
apply_healthcare_policy() {
    echo "Application de la politique santé..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.sharing"
        "com.apple.preference.network"
        "com.apple.prefs.backup"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique santé appliquée - axée sur la conformité HIPAA"
}

# Politique financière (sécurité renforcée)
apply_financial_policy() {
    echo "Application de la politique financière..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preferences.sharing"
        "com.apple.preference.network"
        "com.apple.prefs.backup"
        "com.apple.preferences.extensions"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique financière appliquée - restrictions de sécurité renforcées"
}

# Politique terminal public (protection maximale)
apply_public_terminal_policy() {
    echo "Application de la politique terminal public..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preferences.sharing"
        "com.apple.preference.network"
        "com.apple.prefs.backup"
        "com.apple.preferences.softwareupdate"
        "com.apple.preference.datetime"
        "com.apple.preference.startupdisk"
        "com.apple.preferences.extensions"
        "com.apple.preference.energysaver"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        HiddenPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique terminal public appliquée - protection maximale"
}

# Politique exécutif (restrictions minimales, accès complet)
apply_executive_policy() {
    echo "Application de la politique exécutif..."
    # Supprimer toutes les restrictions pour les exécutifs
    defaults delete "/Library/Preferences/com.apple.systempreferences" HiddenPreferencePanes 2>/dev/null
    defaults delete "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null
    
    echo "✓ Politique exécutif appliquée - accès complet accordé"
}

# Politique contractuel (restrictions d'accès temporaire)
apply_contractor_policy() {
    echo "Application de la politique contractuel..."
    local restricted_panes=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preferences.sharing"
        "com.apple.prefs.backup"
        "com.apple.preferences.softwareupdate"
        "com.apple.preference.startupdisk"
        "com.apple.preferences.extensions"
    )
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${restricted_panes[@]}"
    
    echo "✓ Politique contractuel appliquée - restrictions d'accès temporaire"
}

Outil de Gestion des Préférences Système d'Entreprise

#!/bin/bash

# Outil de Gestion des Préférences Système Roundfleet
# Contrôle complet des panneaux de préférences et gestion de politiques d'entreprise

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_preferences.log"
REPORT_DIR="/etc/roundfleet/reports/preferences"
CONFIG_DIR="/etc/roundfleet/preferences"
POLICY_DIR="/etc/roundfleet/policies/preferences"
BACKUP_DIR="/etc/roundfleet/backups/preferences"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$POLICY_DIR" "$BACKUP_DIR"

# Mapping complet des panneaux de préférences
declare -A PREFERENCE_PANES=(
    ["profiles"]="com.apple.preferences.configurationprofiles"
    ["bluetooth"]="com.apple.preferences.Bluetooth"
    ["network"]="com.apple.preference.network"
    ["security"]="com.apple.preference.security"
    ["users"]="com.apple.preferences.users"
    ["sharing"]="com.apple.preferences.sharing"
    ["timemachine"]="com.apple.prefs.backup"
    ["energy"]="com.apple.preference.energysaver"
    ["displays"]="com.apple.preference.displays"
    ["sound"]="com.apple.preference.sound"
    ["keyboard"]="com.apple.preference.keyboard"
    ["mouse"]="com.apple.preference.mouse"
    ["trackpad"]="com.apple.preference.trackpad"
    ["printers"]="com.apple.preference.printfax"
    ["software_update"]="com.apple.preferences.softwareupdate"
    ["date_time"]="com.apple.preference.datetime"
    ["startup_disk"]="com.apple.preference.startupdisk"
    ["accessibility"]="com.apple.preference.universalaccess"
    ["screen_time"]="com.apple.preference.screentime"
    ["extensions"]="com.apple.preferences.extensions"
    ["spotlight"]="com.apple.preference.spotlight"
    ["language_region"]="com.apple.Localization"
    ["desktop_screensaver"]="com.apple.preference.desktopscreeneffect"
    ["dock"]="com.apple.preference.dock"
    ["mission_control"]="com.apple.preference.expose"
    ["notifications"]="com.apple.preference.notifications"
    ["internet_accounts"]="com.apple.preferences.internetaccounts"
    ["wallet_apple_pay"]="com.apple.preferences.wallet"
    ["siri"]="com.apple.preference.speech"
    ["touch_id"]="com.apple.preferences.password"
)

# Modèles de politiques d'entreprise
declare -A POLICY_TEMPLATES=(
    ["kiosk_mode"]="Restrictions maximales pour kiosques publics et affichages"
    ["locked_down"]="Restrictions de haute sécurité pour environnements sensibles"
    ["standard_office"]="Restrictions modérées pour environnements de bureau typiques"
    ["developer_workstation"]="Restrictions minimales pour environnements de développement"
    ["educational"]="Restrictions appropriées aux étudiants pour institutions éducatives"
    ["healthcare"]="Restrictions conformes HIPAA pour environnements de santé"
    ["financial"]="Sécurité renforcée pour environnements de services financiers"
    ["public_terminal"]="Protection maximale pour terminaux d'accès public"
    ["executive"]="Restrictions minimales à nulles pour utilisateurs exécutifs"
    ["contractor"]="Restrictions d'accès temporaire pour travailleurs contractuels"
)

# Cadres de conformité
declare -A COMPLIANCE_FRAMEWORKS=(
    ["hipaa"]="Health Insurance Portability and Accountability Act"
    ["sox"]="Conformité Sarbanes-Oxley Act"
    ["pci_dss"]="Payment Card Industry Data Security Standard"
    ["ferpa"]="Family Educational Rights and Privacy Act"
    ["gdpr"]="General Data Protection Regulation"
    ["nist"]="National Institute of Standards and Technology"
    ["iso27001"]="International Organization for Standardization 27001"
    ["cis"]="Center for Internet Security controls"
    ["fisma"]="Federal Information Security Management Act"
    ["common_criteria"]="Standard d'évaluation de sécurité Common Criteria"
)

# Fonction de journalisation
log_action() {
    local message="$1"
    local severity="${2:-INFO}"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] [$severity] $message" | tee -a "$LOG_FILE"
}

# Gestion des préférences système d'entreprise
enterprise_preferences_management() {
    local operation="${1:-status}"
    local policy_name="${2:-standard_office}"
    local target_panes="${3:-}"
    local compliance_framework="${4:-}"
    
    log_action "Démarrage gestion préférences d'entreprise" "INFO"
    log_action "Opération : $operation, Politique : $policy_name" "INFO"
    
    echo "=== Gestion des Préférences Système d'Entreprise ==="
    echo "Opération : $operation"
    echo "Politique : $policy_name"
    echo "Panneaux Cibles : ${target_panes:-tous_définis_par_politique}"
    echo "Cadre de Conformité : ${compliance_framework:-aucun}"
    echo "ID de Gestion : $(uuidgen)"
    echo ""
    
    # Sauvegarder la configuration actuelle
    backup_current_configuration
    
    case "$operation" in
        "apply_policy")
            apply_enterprise_policy "$policy_name" "$compliance_framework"
            ;;
        "hide_panes")
            if [[ -n "$target_panes" ]]; then
                hide_specific_panes "$target_panes"
            else
                echo "Erreur : Aucun panneau cible spécifié pour l'opération de masquage"
                return 1
            fi
            ;;
        "disable_panes")
            if [[ -n "$target_panes" ]]; then
                disable_specific_panes "$target_panes"
            else
                echo "Erreur : Aucun panneau cible spécifié pour l'opération de désactivation"
                return 1
            fi
            ;;
        "restore_all")
            restore_all_preferences
            ;;
        "status")
            show_preferences_status
            ;;
        "audit")
            perform_preferences_audit "$compliance_framework"
            ;;
        "list_policies")
            list_available_policies
            ;;
        "list_panes")
            list_available_panes
            ;;
        *)
            echo "Opération inconnue : $operation"
            return 1
            ;;
    esac
    
    # Générer le rapport de gestion
    generate_preferences_report "$operation" "$policy_name" "$target_panes" "$compliance_framework"
    
    log_action "Gestion des préférences d'entreprise terminée" "INFO"
}

# Sauvegarder la configuration actuelle
backup_current_configuration() {
    local backup_file="$BACKUP_DIR/preferences_backup_$(date +%Y%m%d_%H%M%S).plist"
    
    echo "--- Création de Sauvegarde de Configuration ---"
    
    # Copier la configuration actuelle des préférences système
    if [[ -f "/Library/Preferences/com.apple.systempreferences.plist" ]]; then
        cp "/Library/Preferences/com.apple.systempreferences.plist" "$backup_file"
        echo "✓ Configuration sauvegardée dans : $backup_file"
        log_action "Configuration sauvegardée : $backup_file" "INFO"
    else
        echo "⚠️ Aucun fichier de configuration existant trouvé"
        log_action "Aucun fichier de configuration existant à sauvegarder" "WARNING"
    fi
}

# Appliquer la politique d'entreprise avec considérations de conformité
apply_enterprise_policy() {
    local policy_name="$1"
    local compliance_framework="$2"
    
    echo "--- Application de Politique d'Entreprise ---"
    echo "Politique : $policy_name"
    echo "Conformité : ${compliance_framework:-aucune}"
    
    # Appliquer la politique de base
    case "$policy_name" in
        "kiosk_mode")
            apply_kiosk_mode_policy
            ;;
        "locked_down")
            apply_locked_down_policy
            ;;
        "standard_office")
            apply_standard_office_policy
            ;;
        "developer_workstation")
            apply_developer_workstation_policy
            ;;
        "educational")
            apply_educational_policy
            ;;
        "healthcare")
            apply_healthcare_policy
            ;;
        "financial")
            apply_financial_policy
            ;;
        "public_terminal")
            apply_public_terminal_policy
            ;;
        "executive")
            apply_executive_policy
            ;;
        "contractor")
            apply_contractor_policy
            ;;
        *)
            echo "Politique inconnue : $policy_name"
            return 1
            ;;
    esac
    
    # Appliquer les modifications spécifiques à la conformité
    if [[ -n "$compliance_framework" ]]; then
        apply_compliance_modifications "$compliance_framework"
    fi
    
    echo "✓ Politique d'entreprise appliquée avec succès"
}

# Appliquer les modifications spécifiques à la conformité
apply_compliance_modifications() {
    local framework="$1"
    
    echo "--- Application de Modifications de Conformité ---"
    echo "Cadre : $framework"
    
    case "$framework" in
        "hipaa")
            apply_hipaa_compliance
            ;;
        "sox")
            apply_sox_compliance
            ;;
        "pci_dss")
            apply_pci_dss_compliance
            ;;
        "ferpa")
            apply_ferpa_compliance
            ;;
        "gdpr")
            apply_gdpr_compliance
            ;;
        *)
            echo "Cadre de conformité inconnu : $framework"
            ;;
    esac
}

# Modifications de conformité HIPAA
apply_hipaa_compliance() {
    echo "Application des modifications de conformité HIPAA..."
    
    # Restrictions supplémentaires pour la protection des données de santé
    local hipaa_restricted=(
        "com.apple.preferences.sharing"
        "com.apple.preference.network"
        "com.apple.prefs.backup"
        "com.apple.preferences.internetaccounts"
    )
    
    # Obtenir les panneaux actuellement désactivés
    local current_disabled=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    
    # Combiner avec les exigences HIPAA
    local combined_disabled=($current_disabled "${hipaa_restricted[@]}")
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${combined_disabled[@]}"
    
    echo "✓ Modifications de conformité HIPAA appliquées"
}

# Modifications de conformité SOX
apply_sox_compliance() {
    echo "Application des modifications de conformité SOX..."
    
    # Exigences d'audit et de contrôle financier
    local sox_restricted=(
        "com.apple.preferences.configurationprofiles"
        "com.apple.preference.security"
        "com.apple.preferences.users"
        "com.apple.preference.datetime"
    )
    
    # Modèle similaire pour SOX
    local current_disabled=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    local combined_disabled=($current_disabled "${sox_restricted[@]}")
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${combined_disabled[@]}"
    
    echo "✓ Modifications de conformité SOX appliquées"
}

# Modifications de conformité PCI DSS
apply_pci_dss_compliance() {
    echo "Application des modifications de conformité PCI DSS..."
    
    # Exigences de l'industrie des cartes de paiement
    local pci_restricted=(
        "com.apple.preferences.sharing"
        "com.apple.preference.network"
        "com.apple.preference.security"
        "com.apple.preferences.extensions"
    )
    
    local current_disabled=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    local combined_disabled=($current_disabled "${pci_restricted[@]}")
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${combined_disabled[@]}"
    
    echo "✓ Modifications de conformité PCI DSS appliquées"
}

# Modifications de conformité FERPA
apply_ferpa_compliance() {
    echo "Application des modifications de conformité FERPA..."
    
    # Exigences de confidentialité éducative
    local ferpa_restricted=(
        "com.apple.preferences.sharing"
        "com.apple.preferences.internetaccounts"
        "com.apple.prefs.backup"
    )
    
    local current_disabled=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    local combined_disabled=($current_disabled "${ferpa_restricted[@]}")
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${combined_disabled[@]}"
    
    echo "✓ Modifications de conformité FERPA appliquées"
}

# Modifications de conformité GDPR
apply_gdpr_compliance() {
    echo "Application des modifications de conformité GDPR..."
    
    # Exigences de protection des données européennes
    local gdpr_restricted=(
        "com.apple.preferences.sharing"
        "com.apple.prefs.backup"
        "com.apple.preferences.internetaccounts"
        "com.apple.preference.notifications"
    )
    
    local current_disabled=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    local combined_disabled=($current_disabled "${gdpr_restricted[@]}")
    
    defaults write "/Library/Preferences/com.apple.systempreferences" \
        DisabledPreferencePanes -array "${combined_disabled[@]}"
    
    echo "✓ Modifications de conformité GDPR appliquées"
}

# Afficher le statut actuel des préférences
show_preferences_status() {
    echo "--- Statut des Préférences Système ---"
    
    # Vérifier les panneaux masqués
    local hidden_panes=$(defaults read "/Library/Preferences/com.apple.systempreferences" HiddenPreferencePanes 2>/dev/null)
    if [[ -n "$hidden_panes" ]]; then
        echo "Panneaux Masqués :"
        echo "$hidden_panes" | tr -d '(),"' | tr '\n' ' ' | xargs -n1 | while read pane; do
            if [[ -n "$pane" ]]; then
                local friendly_name=$(get_friendly_name "$pane")
                echo "  - $friendly_name ($pane)"
            fi
        done
    else
        echo "Panneaux Masqués : Aucun"
    fi
    
    echo ""
    
    # Vérifier les panneaux désactivés
    local disabled_panes=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null)
    if [[ -n "$disabled_panes" ]]; then
        echo "Panneaux Désactivés :"
        echo "$disabled_panes" | tr -d '(),"' | tr '\n' ' ' | xargs -n1 | while read pane; do
            if [[ -n "$pane" ]]; then
                local friendly_name=$(get_friendly_name "$pane")
                echo "  - $friendly_name ($pane)"
            fi
        done
    else
        echo "Panneaux Désactivés : Aucun"
    fi
}

# Obtenir le nom convivial à partir de l'identifiant de bundle
get_friendly_name() {
    local bundle_id="$1"
    
    for friendly_name in "${!PREFERENCE_PANES[@]}"; do
        if [[ "${PREFERENCE_PANES[$friendly_name]}" == "$bundle_id" ]]; then
            echo "$friendly_name"
            return
        fi
    done
    
    echo "inconnu"
}

# Générer un rapport de préférences complet
generate_preferences_report() {
    local operation="$1"
    local policy_name="$2"
    local target_panes="$3"
    local compliance_framework="$4"
    
    local report_file="$REPORT_DIR/preferences_report_$(date +%Y%m%d_%H%M%S).json"
    
    # Obtenir la configuration actuelle
    local hidden_panes=$(defaults read "/Library/Preferences/com.apple.systempreferences" HiddenPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    local disabled_panes=$(defaults read "/Library/Preferences/com.apple.systempreferences" DisabledPreferencePanes 2>/dev/null | tr -d '(),"' | tr '\n' ' ')
    
    cat > "$report_file" << EOF
{
    "preferences_report": {
        "report_metadata": {
            "report_id": "$(uuidgen)",
            "generated_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
            "hostname": "$(hostname)",
            "script_version": "$SCRIPT_VERSION",
            "macos_version": "$(sw_vers -productVersion)"
        },
        "operation_details": {
            "operation": "$operation",
            "policy_name": "$policy_name",
            "target_panes": "$target_panes",
            "compliance_framework": "$compliance_framework"
        },
        "current_configuration": {
            "hidden_panes": "$hidden_panes",
            "disabled_panes": "$disabled_panes",
            "total_restrictions": $(echo "$hidden_panes $disabled_panes" | wc -w)
        },
        "system_information": {
            "total_preference_panes": ${#PREFERENCE_PANES[@]},
            "available_policies": ${#POLICY_TEMPLATES[@]},
            "compliance_frameworks": ${#COMPLIANCE_FRAMEWORKS[@]}
        }
    }
}
EOF
    
    echo "Rapport de préférences généré : $report_file"
    log_action "Rapport de préférences généré : $report_file" "INFO"
}

# Lister les politiques disponibles
list_available_policies() {
    echo "--- Politiques d'Entreprise Disponibles ---"
    for policy in "${!POLICY_TEMPLATES[@]}"; do
        echo "  $policy : ${POLICY_TEMPLATES[$policy]}"
    done
}

# Lister les panneaux de préférences disponibles
list_available_panes() {
    echo "--- Panneaux de Préférences Disponibles ---"
    for pane in "${!PREFERENCE_PANES[@]}"; do
        echo "  $pane : ${PREFERENCE_PANES[$pane]}"
    done
}

# Fonction d'exécution principale
main() {
    local operation="${1:-help}"
    local policy="${2:-}"
    local panes="${3:-}"
    local compliance="${4:-}"
    
    log_action "=== Gestion des Préférences Système Roundfleet Démarrée ===" "INFO"
    log_action "Opération : $operation" "INFO"
    
    case "$operation" in
        "apply")
            if [[ -z "$policy" ]]; then
                echo "Usage : $0 apply <nom_politique> [cadre_conformité]"
                echo "Politiques disponibles : ${!POLICY_TEMPLATES[*]}"
                exit 1
            fi
            enterprise_preferences_management "apply_policy" "$policy" "" "$compliance"
            ;;
        "hide")
            if [[ -z "$panes" ]]; then
                echo "Usage : $0 hide <panneau1,panneau2,...>"
                echo "Panneaux disponibles : ${!PREFERENCE_PANES[*]}"
                exit 1
            fi
            enterprise_preferences_management "hide_panes" "" "$panes"
            ;;
        "disable")
            if [[ -z "$panes" ]]; then
                echo "Usage : $0 disable <panneau1,panneau2,...>"
                echo "Panneaux disponibles : ${!PREFERENCE_PANES[*]}"
                exit 1
            fi
            enterprise_preferences_management "disable_panes" "" "$panes"
            ;;
        "restore")
            enterprise_preferences_management "restore_all"
            ;;
        "status")
            enterprise_preferences_management "status"
            ;;
        "audit")
            enterprise_preferences_management "audit" "" "" "$policy"
            ;;
        "list-policies")
            enterprise_preferences_management "list_policies"
            ;;
        "list-panes")
            enterprise_preferences_management "list_panes"
            ;;
        "help")
            echo "Usage : $0 [opération] [options...]"
            echo "Opérations :"
            echo "  apply <politique> [conformité] - Appliquer une politique d'entreprise"
            echo "  hide <panneaux> - Masquer des panneaux de préférences spécifiques"
            echo "  disable <panneaux> - Désactiver des panneaux de préférences spécifiques"
            echo "  restore - Restaurer tous les panneaux de préférences"
            echo "  status - Afficher le statut actuel des préférences"
            echo "  audit [conformité] - Effectuer un audit de conformité"
            echo "  list-policies - Lister les politiques disponibles"
            echo "  list-panes - Lister les panneaux de préférences disponibles"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Politiques Disponibles : ${!POLICY_TEMPLATES[*]}"
            echo "Cadres de Conformité : ${!COMPLIANCE_FRAMEWORKS[*]}"
            ;;
        *)
            log_action "ERREUR : Opération inconnue : $operation" "ERROR"
            echo "Utilisez '$0 help' pour les informations d'utilisation"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des préférences système terminée ===" "INFO"
}

# Exécuter la fonction principale
main "$@"

Considérations Importantes

Compatibilité des Versions macOS

• Masquage des Panneaux : Nécessite macOS 13.0 ou ultérieur (HiddenPreferencePanes)
• Désactivation des Panneaux : Fonctionne sur macOS 10.2 et ultérieur (DisabledPreferencePanes)
• Identifiants de Bundle : Peuvent changer entre les versions macOS
• Protection d'Intégrité Système : Certaines restrictions peuvent ne pas s'appliquer avec SIP activé

Notes de Déploiement d'Entreprise

• Impact Utilisateur : Les panneaux masqués/désactivés affectent tous les utilisateurs sur l'appareil
• Accès Administratif : Les modifications nécessitent des privilèges administrateur
• Test de Politiques : Toujours tester les politiques sur des appareils non-production d'abord
• Sauvegarde et Récupération : Maintenir des sauvegardes de configuration pour le rollback de politique

Considérations de Sécurité et Conformité

• Principe du Moindre Privilège : Restreindre l'accès uniquement aux panneaux de préférences nécessaires
• Journalisation d'Audit : Tous les changements de préférences doivent être journalisés pour la conformité
• Cadres de Conformité : Différentes industries nécessitent des restrictions spécifiques
• Formation Utilisateur : Informer les utilisateurs sur les fonctionnalités restreintes et les alternatives

Collectez et analysez les informations système complètes de vos appareils Roundfleet en utilisant le profilage système avancé, la collecte automatisée de données et l'analytique de niveau entreprise. Ce tutoriel fournit des outils puissants pour implémenter l'inventaire organisationnel des appareils, la surveillance et les rapports de conformité.

Comprendre l'Information Système macOS

macOS fournit plusieurs outils pour la collecte d'informations système :

• system_profiler - Collecte complète d'informations système
• uname - Informations de base du système et du noyau
• sw_vers - Informations de version logicielle
• hwpref - Données de préférence matérielle
• ioreg - Informations matérielles du registre I/O
• Information Système.app - Interface graphique d'information système

Opérations d'Information Système de Base

Information Système Complète

#!/bin/bash

# Obtenir l'information système complète
echo "=== Information Système Complète ==="
system_profiler

echo "Collecte d'information système terminée"

Lister les Types de Données Disponibles

#!/bin/bash

# Lister tous les types de données system_profiler disponibles
echo "=== Types de Données Disponibles ==="
system_profiler --listDataTypes

echo "Listage des types de données terminé"

Information Système Spécifique

#!/bin/bash

# Obtenir une information système spécifique
DATA_TYPE="${1:-SPHardwareDataType}"

echo "=== Information $DATA_TYPE ==="
system_profiler "$DATA_TYPE"

echo "Information système spécifique récupérée"

Sauvegarder le Rapport Système dans un Fichier

#!/bin/bash

# Sauvegarder l'information système dans un fichier
REPORT_FILE="${1:-/tmp/system_report_$(date +%Y%m%d_%H%M%S).txt}"

echo "=== Sauvegarde du Rapport Système ==="
system_profiler > "$REPORT_FILE"

echo "Rapport système sauvegardé dans : $REPORT_FILE"

Système de Gestion d'Information Système d'Entreprise

#!/bin/bash

# Système de Gestion d'Information Système d'Entreprise Roundfleet
# Collecte complète de données système, analyse et surveillance

# Configuration
ROUNDFLEET_DIR="/etc/roundfleet"
SYSINFO_DIR="$ROUNDFLEET_DIR/system_information"
REPORTS_DIR="$ROUNDFLEET_DIR/reports"
COMPLIANCE_DIR="$ROUNDFLEET_DIR/compliance"
AUDIT_DIR="$ROUNDFLEET_DIR/audit"
LOG_FILE="/var/log/roundfleet_system_information.log"
POLICIES_DIR="$ROUNDFLEET_DIR/system_policies"
INVENTORY_DIR="$ROUNDFLEET_DIR/inventory"

# Créer la structure de répertoires
create_directories() {
    local dirs=("$ROUNDFLEET_DIR" "$SYSINFO_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR" "$POLICIES_DIR" "$INVENTORY_DIR")
    for dir in "${dirs[@]}"; do
        [[ ! -d "$dir" ]] && mkdir -p "$dir"
    done
}

# Fonction de journalisation
log_action() {
    local message="$1"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] $message" | tee -a "$LOG_FILE"
}

# Catégories d'Information Système pour la Gestion d'Entreprise
declare -A SYSTEM_CATEGORIES=(
    ["hardware_overview"]="SPHardwareDataType,SPMemoryDataType,SPStorageDataType"
    ["software_inventory"]="SPSoftwareDataType,SPApplicationsDataType,SPExtensionsDataType"
    ["network_configuration"]="SPNetworkDataType,SPBluetoothDataType,SPWWANDataType"
    ["security_configuration"]="SPFirewallDataType,SPManagedClientDataType,SPConfigurationProfileDataType"
    ["peripherals"]="SPUSBDataType,SPThunderboltDataType,SPAudioDataType,SPDisplaysDataType"
    ["system_diagnostics"]="SPPowerDataType,SPLogsDataType,SPDiagnosticsDataType"
    ["enterprise_management"]="SPManagedClientDataType,SPConfigurationProfileDataType,SPCertificatesDataType"
)

# Politiques de Collecte de Données
declare -A COLLECTION_POLICIES=(
    ["comprehensive"]="all_data_types,full_detail,include_sensitive,export_json"
    ["security_focused"]="security_data,certificates,firewall_config,managed_profiles"
    ["hardware_inventory"]="hardware_overview,storage_details,memory_config,peripherals"
    ["software_audit"]="applications,extensions,system_software,preferences"
    ["network_assessment"]="network_interfaces,bluetooth_devices,wireless_config"
    ["compliance_report"]="security_config,certificates,managed_profiles,audit_data"
)

# Seuils de Surveillance de Santé Système
declare -A HEALTH_THRESHOLDS=(
    ["cpu_temperature_warning"]=80
    ["memory_pressure_warning"]=80
    ["storage_usage_warning"]=85
    ["battery_cycle_warning"]=800
    ["uptime_excessive_hours"]=168  # 1 semaine
)

# Collecte complète d'information système
collect_system_information() {
    local collection_policy="$1"
    local output_format="${2:-json}"
    local include_sensitive="${3:-false}"
    local collection_id="sysinfo_$(date +%Y%m%d_%H%M%S)"
    local output_file="$SYSINFO_DIR/${collection_id}.${output_format}"
    
    log_action "Démarrage de la collecte d'information système : $collection_policy"
    
    # Initialiser les métadonnées de collecte
    local hostname=$(hostname)
    local serial_number=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')
    local model_identifier=$(system_profiler SPHardwareDataType | grep "Model Identifier" | awk '{print $3}')
    local os_version=$(sw_vers -productVersion)
    local build_version=$(sw_vers -buildVersion)
    local uptime=$(uptime | awk '{print $3,$4}' | sed 's/,//')
    
    # Collecter les données selon la politique
    local collected_data=""
    local data_types=""
    
    case "$collection_policy" in
        "comprehensive")
            data_types=$(system_profiler --listDataTypes | tr '\n' ' ')
            ;;
        "security_focused")
            data_types="SPFirewallDataType SPManagedClientDataType SPConfigurationProfileDataType SPCertificatesDataType"
            ;;
        "hardware_inventory")
            data_types="SPHardwareDataType SPMemoryDataType SPStorageDataType SPUSBDataType SPDisplaysDataType SPAudioDataType"
            ;;
        "software_audit")
            data_types="SPSoftwareDataType SPApplicationsDataType SPExtensionsDataType SPPrefPaneDataType"
            ;;
        "network_assessment")
            data_types="SPNetworkDataType SPBluetoothDataType SPWWANDataType SPAirPortDataType"
            ;;
        "compliance_report")
            data_types="SPManagedClientDataType SPConfigurationProfileDataType SPCertificatesDataType SPFirewallDataType"
            ;;
    esac
    
    # Collecter les données pour chaque type spécifié
    for data_type in $data_types; do
        [[ -z "$data_type" ]] && continue
        
        log_action "Collecte du type de données : $data_type"
        
        if [[ "$output_format" == "json" ]]; then
            local type_data=$(system_profiler -json "$data_type" 2>/dev/null)
            if [[ -n "$type_data" && "$type_data" != "null" ]]; then
                collected_data="$collected_data\"$data_type\":$type_data,"
            fi
        else
            local type_data=$(system_profiler "$data_type" 2>/dev/null)
            if [[ -n "$type_data" ]]; then
                collected_data="$collected_data\n=== $data_type ===\n$type_data\n"
            fi
        fi
    done
    
    # Métriques système supplémentaires
    local additional_metrics=""
    if [[ "$include_sensitive" == "true" || "$collection_policy" == "comprehensive" ]]; then
        local cpu_info=$(sysctl -n machdep.cpu.brand_string)
        local memory_total=$(system_profiler SPHardwareDataType | grep "Memory:" | awk '{print $2,$3}')
        local storage_info=$(df -h / | awk 'NR==2 {print $2,$3,$4,$5}')
        local network_interfaces=$(ifconfig | grep "^[a-z]" | awk '{print $1}' | sed 's/:$//' | tr '\n' ' ')
        local running_processes=$(ps aux | wc -l)
        local logged_in_users=$(who | wc -l)
        
        additional_metrics="{\"cpu_info\":\"$cpu_info\",\"memory_total\":\"$memory_total\",\"storage_info\":\"$storage_info\",\"network_interfaces\":\"$network_interfaces\",\"running_processes\":$running_processes,\"logged_in_users\":$logged_in_users}"
    fi
    
    # Créer une sortie structurée
    if [[ "$output_format" == "json" ]]; then
        # Supprimer la virgule finale des données collectées
        collected_data="${collected_data%,}"
        
        cat > "$output_file" << EOF
{
  "collection_metadata": {
    "collection_id": "$collection_id",
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "policy": "$collection_policy",
    "hostname": "$hostname",
    "serial_number": "$serial_number",
    "model_identifier": "$model_identifier",
    "os_version": "$os_version",
    "build_version": "$build_version",
    "uptime": "$uptime"
  },
  "system_data": {$collected_data},
  "additional_metrics": $additional_metrics,
  "collection_summary": {
    "data_types_collected": $(echo "$data_types" | wc -w),
    "include_sensitive": "$include_sensitive",
    "collection_size_bytes": $(wc -c < "$output_file" 2>/dev/null || echo "0")
  }
}
EOF
    else
        cat > "$output_file" << EOF
=== Rapport d'Information Système Roundfleet ===
ID de Collecte : $collection_id
Horodatage : $(date)
Politique : $collection_policy
Nom d'hôte : $hostname
Numéro de Série : $serial_number
Modèle : $model_identifier
Version OS : $os_version ($build_version)
Temps de fonctionnement : $uptime

$collected_data
EOF
    fi
    
    log_action "Collecte d'information système terminée : $output_file"
    echo "$output_file"
}

# Analyse de santé système
analyze_system_health() {
    local analysis_type="$1"
    local health_report="$REPORTS_DIR/system_health_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Démarrage de l'analyse de santé système : $analysis_type"
    
    # Collecter les métriques de santé de base
    local cpu_temp=$(sudo powermetrics -n 1 -s cpu_power | grep "CPU die temperature" | awk '{print $4}' 2>/dev/null || echo "0")
    local memory_pressure=$(vm_stat | grep "Pages compressed" | awk '{print $3}' | sed 's/\.//' | head -1)
    local storage_usage=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
    local uptime_seconds=$(sysctl -n kern.boottime | awk '{print $4}' | sed 's/,//')
    local current_time=$(date +%s)
    local uptime_hours=$(( (current_time - uptime_seconds) / 3600 ))
    
    # Analyse de charge système
    local load_average=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | sed 's/,//')
    local cpu_cores=$(sysctl -n hw.ncpu)
    local load_per_core=$(echo "scale=2; $load_average / $cpu_cores" | bc -l 2>/dev/null || echo "0")
    
    # Informations de batterie (si disponible)
    local battery_cycle_count=0
    local battery_condition="Inconnu"
    if system_profiler SPPowerDataType | grep -q "Cycle Count"; then
        battery_cycle_count=$(system_profiler SPPowerDataType | grep "Cycle Count" | awk '{print $3}')
        battery_condition=$(system_profiler SPPowerDataType | grep "Condition" | awk '{print $2}')
    fi
    
    # Déterminer l'état de santé
    local health_status="healthy"
    local health_alerts=""
    
    if [[ $(echo "$cpu_temp > ${HEALTH_THRESHOLDS[cpu_temperature_warning]}" | bc -l 2>/dev/null) -eq 1 ]]; then
        health_status="warning"
        health_alerts="$health_alerts\"Température CPU élevée : ${cpu_temp}°C\","
    fi
    
    if [[ $storage_usage -gt ${HEALTH_THRESHOLDS[storage_usage_warning]} ]]; then
        health_status="warning"
        health_alerts="$health_alerts\"Utilisation stockage élevée : ${storage_usage}%\","
    fi
    
    if [[ $battery_cycle_count -gt ${HEALTH_THRESHOLDS[battery_cycle_warning]} ]]; then
        health_status="warning"
        health_alerts="$health_alerts\"Nombre de cycles batterie élevé : $battery_cycle_count\","
    fi
    
    if [[ $uptime_hours -gt ${HEALTH_THRESHOLDS[uptime_excessive_hours]} ]]; then
        health_status="attention"
        health_alerts="$health_alerts\"Temps de fonctionnement excessif : ${uptime_hours} heures\","
    fi
    
    # Supprimer la virgule finale
    health_alerts="${health_alerts%,}"
    
    # Créer le rapport de santé
    cat > "$health_report" << EOF
{
  "system_health_analysis": {
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "analysis_type": "$analysis_type",
    "health_status": "$health_status",
    "device_info": {
      "hostname": "$(hostname)",
      "serial_number": "$(system_profiler SPHardwareDataType | grep "Serial Number" | awk '{print $4}')",
      "model": "$(system_profiler SPHardwareDataType | grep "Model Identifier" | awk '{print $3}')",
      "os_version": "$(sw_vers -productVersion)"
    }
  },
  "health_metrics": {
    "cpu_temperature_celsius": "$cpu_temp",
    "memory_pressure_pages": "$memory_pressure",
    "storage_usage_percent": $storage_usage,
    "uptime_hours": $uptime_hours,
    "load_average": "$load_average",
    "load_per_core": "$load_per_core",
    "cpu_cores": $cpu_cores,
    "battery_cycle_count": $battery_cycle_count,
    "battery_condition": "$battery_condition"
  },
  "health_alerts": [$health_alerts],
  "recommendations": [
    $([ "$health_status" != "healthy" ] && echo "\"Traiter les alertes de santé pour performance optimale\",")
    $([ $uptime_hours -gt 72 ] && echo "\"Considérer redémarrage système pour performance optimale\",")
    $([ $storage_usage -gt 80 ] && echo "\"Réviser utilisation stockage et nettoyer si nécessaire\",")
    "\"Surveillance régulière de santé recommandée\""
  ]
}
EOF
    
    if [[ "$health_status" != "healthy" ]]; then
        log_action "AVERTISSEMENT SANTÉ : Problèmes de santé système détectés - $health_status"
    fi
    
    log_action "Analyse de santé système terminée : $health_report"
    echo "$health_report"
}

# Fonction d'exécution principale
main() {
    create_directories
    
    case "${1:-}" in
        "collect")
            collect_system_information "${2:-comprehensive}" "${3:-json}" "${4:-false}"
            ;;
        "analyze_health")
            analyze_system_health "${2:-standard}"
            ;;
        "help"|*)
            echo "Système de Gestion d'Information Système d'Entreprise Roundfleet"
            echo ""
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  collect [politique] [format] [sensible]  - Collecter information système (comprehensive|security_focused|hardware_inventory|software_audit|network_assessment|compliance_report) [json|text] [true|false]"
            echo "  analyze_health [type]                    - Analyser santé système (standard|detailed|continuous)"
            echo ""
            echo "Exemples :"
            echo "  $0 collect comprehensive json false"
            echo "  $0 analyze_health detailed"
            ;;
    esac
}

# Exécuter la fonction principale
main "$@"

Types de Données d'Information Système

Le système d'entreprise supporte la collecte complète de types de données :

Politiques de Collecte d'Entreprise

Collecte Complète

# Collecter toutes les informations système disponibles
./sysinfo_manager.sh collect comprehensive json false

# Inclure les informations sensibles pour analyse détaillée
./sysinfo_manager.sh collect comprehensive json true

Collecte Axée Sécurité

# Collecter uniquement les informations pertinentes à la sécurité
./sysinfo_manager.sh collect security_focused json false

Inventaire Matériel

# Collecter les données d'inventaire matériel
./sysinfo_manager.sh collect hardware_inventory json false

Surveillance de Santé Système

Analyse de Santé

# Effectuer analyse de santé standard
./sysinfo_manager.sh analyze_health standard

# Analyse de santé détaillée avec métriques complètes
./sysinfo_manager.sh analyze_health detailed

Considérations Importantes de Sécurité

• Sensibilité des données nécessite manipulation et chiffrement appropriés
• Contrôles d'accès doivent être implémentés pour informations système sensibles
• Journalisation d'audit doit suivre tous les accès et collectes d'information système
• Sécurité réseau doit protéger transmission de données entre appareils
• Exigences de conformité varient selon l'industrie et la localisation géographique

Performance et Évolutivité

Le système d'entreprise est conçu pour :

• Déploiement à grande échelle sur des milliers d'appareils
• Collecte efficace de données avec impact système minimal
• Stockage évolutif pour données historiques et analyse de tendances
• Haute disponibilité avec redondance et capacités de basculement
• Optimisation de performance pour diverses configurations matérielles

Ce système complet transforme la récupération d'information système de base en une plateforme de gestion et surveillance d'appareils de niveau entreprise avec analytique avancée, rapports de conformité et capacités de gestion de flotte.

Surveillez et optimisez le stockage de vos appareils Roundfleet en utilisant l'analyse avancée d'utilisation du disque, les politiques de nettoyage automatisées et la gestion complète de stockage. Ce tutoriel fournit des outils de niveau entreprise pour implémenter les politiques de stockage organisationnelles et l'optimisation de stockage à l'échelle de la flotte.

Comprendre la Gestion de Stockage macOS

macOS fournit plusieurs outils en ligne de commande pour la gestion de stockage :

• du - Analyse d'utilisation de répertoires et consommation d'espace
• df - Espace disque libre et informations du système de fichiers
• diskutil - Utilitaire de disque pour opérations avancées de disque
• tmutil - Utilitaire Time Machine pour stockage de sauvegarde
• Gestion de Stockage - Interface d'optimisation de stockage graphique

Opérations de Stockage de Base

Vérifier l'Utilisation de Stockage des Utilisateurs

#!/bin/bash

# Vérifier l'utilisation du disque pour tous les utilisateurs
echo "=== Utilisation de Stockage des Utilisateurs ==="
sudo du -hxd1 /Users

echo "Vérification d'utilisation de stockage terminée"

Vérifier l'Utilisation du Système de Fichiers

#!/bin/bash

# Vérifier l'utilisation globale du système de fichiers
echo "=== Utilisation du Système de Fichiers ==="
df -h

# Vérifier un système de fichiers spécifique
# df -h /dev/disk1s1

echo "Vérification d'utilisation du système de fichiers terminée"

Vérifier l'Utilisation du Répertoire Actuel

#!/bin/bash

# Vérifier l'utilisation du répertoire actuel
echo "=== Utilisation du Répertoire Actuel ==="
du -sh *

echo "Vérification d'utilisation du répertoire terminée"

Système de Gestion de Stockage d'Entreprise

#!/bin/bash

# Système de Gestion de Stockage d'Entreprise Roundfleet
# Surveillance complète de stockage, optimisation et gestion de politiques

# Configuration
ROUNDFLEET_DIR="/etc/roundfleet"
STORAGE_DIR="$ROUNDFLEET_DIR/storage_management"
REPORTS_DIR="$ROUNDFLEET_DIR/reports"
COMPLIANCE_DIR="$ROUNDFLEET_DIR/compliance"
AUDIT_DIR="$ROUNDFLEET_DIR/audit"
LOG_FILE="/var/log/roundfleet_storage_management.log"
POLICIES_DIR="$ROUNDFLEET_DIR/storage_policies"
CLEANUP_DIR="$ROUNDFLEET_DIR/cleanup_logs"

# Créer la structure de répertoires
create_directories() {
    local dirs=("$ROUNDFLEET_DIR" "$STORAGE_DIR" "$REPORTS_DIR" "$COMPLIANCE_DIR" "$AUDIT_DIR" "$POLICIES_DIR" "$CLEANUP_DIR")
    for dir in "${dirs[@]}"; do
        [[ ! -d "$dir" ]] && mkdir -p "$dir"
    done
}

# Fonction de journalisation
log_action() {
    local message="$1"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] $message" | tee -a "$LOG_FILE"
}

# Catégories de Stockage pour la Gestion d'Entreprise
declare -A STORAGE_CATEGORIES=(
    ["system_critical"]="macOS,system_apps,kernel_extensions,system_logs"
    ["user_data"]="documents,downloads,desktop,pictures,movies"
    ["application_data"]="app_support,caches,preferences,saved_states"
    ["development"]="xcode,simulators,build_artifacts,source_code"
    ["media_content"]="photos,videos,music,podcasts"
    ["temporary_files"]="caches,logs,trash,temp_downloads"
    ["backup_data"]="time_machine,local_snapshots,manual_backups"
)

# Politiques de Stockage pour Différents Environnements
declare -A STORAGE_POLICIES=(
    ["aggressive_cleanup"]="clear_caches,remove_logs_7days,empty_trash,remove_downloads_30days"
    ["conservative_cleanup"]="clear_caches,remove_logs_30days,archive_old_files"
    ["development_optimized"]="preserve_builds,clear_simulator_data,optimize_xcode_cache"
    ["media_optimized"]="compress_videos,optimize_photos,remove_duplicates"
    ["security_focused"]="secure_delete,encrypt_backups,audit_sensitive_files"
    ["compliance_strict"]="retain_all,encrypt_storage,detailed_logging,no_auto_delete"
)

# Seuils d'Espace Disque pour Différents Niveaux d'Alerte
declare -A ALERT_THRESHOLDS=(
    ["critical"]=5     # Moins de 5GB libres
    ["warning"]=10     # Moins de 10GB libres
    ["low"]=20         # Moins de 20GB libres
    ["optimal"]=50     # Moins de 50GB libres
)

# Analyse complète de stockage
analyze_storage_comprehensive() {
    local analysis_level="$1"
    local output_file="$STORAGE_DIR/storage_analysis_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Démarrage de l'analyse complète de stockage : $analysis_level"
    
    # Obtenir les informations de base du système de fichiers
    local total_space=$(df -h / | awk 'NR==2 {print $2}')
    local used_space=$(df -h / | awk 'NR==2 {print $3}')
    local available_space=$(df -h / | awk 'NR==2 {print $4}')
    local usage_percentage=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
    
    # Convertir en octets pour les calculs
    local available_gb=$(df -g / | awk 'NR==2 {print $4}')
    
    # Déterminer le niveau d'alerte
    local alert_level="optimal"
    if [[ $available_gb -lt ${ALERT_THRESHOLDS["critical"]} ]]; then
        alert_level="critical"
    elif [[ $available_gb -lt ${ALERT_THRESHOLDS["warning"]} ]]; then
        alert_level="warning"
    elif [[ $available_gb -lt ${ALERT_THRESHOLDS["low"]} ]]; then
        alert_level="low"
    fi
    
    # Analyser les répertoires utilisateurs
    local user_data=""
    while IFS= read -r user_dir; do
        if [[ -d "$user_dir" && ! "$user_dir" =~ (Shared|.localized)$ ]]; then
            local user_name=$(basename "$user_dir")
            local user_size=$(du -sg "$user_dir" 2>/dev/null | awk '{print $1}' || echo "0")
            user_data="$user_data{\"user\":\"$user_name\",\"size_gb\":$user_size},"
        fi
    done <<< "$(find /Users -maxdepth 1 -type d)"
    
    # Supprimer la virgule finale
    user_data="${user_data%,}"
    
    # Analyser les grands répertoires
    local large_dirs=""
    if [[ "$analysis_level" == "detailed" || "$analysis_level" == "full" ]]; then
        while IFS= read -r dir_info; do
            local size=$(echo "$dir_info" | awk '{print $1}')
            local path=$(echo "$dir_info" | awk '{$1=""; print substr($0,2)}')
            [[ $size -gt 1 ]] && large_dirs="$large_dirs{\"path\":\"$path\",\"size_gb\":$size},"
        done <<< "$(sudo du -sg /Applications /Library /System /Users 2>/dev/null | sort -nr)"
        large_dirs="${large_dirs%,}"
    fi
    
    # Analyser les caches système et fichiers temporaires
    local temp_data=""
    local cache_size=$(du -sg ~/Library/Caches 2>/dev/null | awk '{print $1}' || echo "0")
    local log_size=$(du -sg /var/log 2>/dev/null | awk '{print $1}' || echo "0")
    local trash_size=$(du -sg ~/.Trash 2>/dev/null | awk '{print $1}' || echo "0")
    
    temp_data="{\"caches_gb\":$cache_size,\"logs_gb\":$log_size,\"trash_gb\":$trash_size}"
    
    # Créer un rapport complet
    cat > "$output_file" << EOF
{
  "storage_analysis": {
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "analysis_level": "$analysis_level",
    "alert_level": "$alert_level",
    "filesystem_info": {
      "total_space": "$total_space",
      "used_space": "$used_space",
      "available_space": "$available_space",
      "usage_percentage": $usage_percentage,
      "available_gb": $available_gb
    },
    "user_breakdown": [$user_data],
    "large_directories": [$large_dirs],
    "temporary_files": $temp_data
  },
  "recommendations": [
    $([ $alert_level == "critical" ] && echo "\"Nettoyage immédiat requis - niveau de stockage critique\",")
    $([ $alert_level == "warning" ] && echo "\"Nettoyage de stockage recommandé\",")
    $([ $cache_size -gt 5 ] && echo "\"Vider les caches d'application ($cache_size GB)\",")
    $([ $trash_size -gt 1 ] && echo "\"Vider la corbeille ($trash_size GB)\",")
    $([ $log_size -gt 2 ] && echo "\"Archiver les anciens fichiers de log ($log_size GB)\",")
    "\"Surveillance régulière du stockage recommandée\""
  ]
}
EOF
    
    log_action "Analyse de stockage terminée. Rapport : $output_file"
    
    # Alerte si critique
    if [[ "$alert_level" == "critical" ]]; then
        log_action "ALERTE CRITIQUE : Espace de stockage critique ($available_gb GB restants)"
        # Envoyer notification d'alerte
        osascript -e "display notification \"Espace de stockage critique : $available_gb GB restants\" with title \"Alerte Stockage Roundfleet\""
    fi
    
    echo "$output_file"
}

# Nettoyage avancé de stockage avec politiques
perform_storage_cleanup() {
    local cleanup_policy="$1"
    local dry_run="${2:-false}"
    local cleanup_report="$CLEANUP_DIR/cleanup_$(date +%Y%m%d_%H%M%S).json"
    
    log_action "Démarrage du nettoyage de stockage avec politique : $cleanup_policy (dry_run: $dry_run)"
    
    local total_freed=0
    local operations=""
    
    case "$cleanup_policy" in
        "aggressive_cleanup")
            # Vider les caches d'application
            if [[ "$dry_run" == "false" ]]; then
                local cache_size_before=$(du -sg ~/Library/Caches 2>/dev/null | awk '{print $1}' || echo "0")
                find ~/Library/Caches -type f -mtime +1 -delete 2>/dev/null
                local cache_size_after=$(du -sg ~/Library/Caches 2>/dev/null | awk '{print $1}' || echo "0")
                local cache_freed=$((cache_size_before - cache_size_after))
                total_freed=$((total_freed + cache_freed))
                operations="$operations{\"operation\":\"clear_caches\",\"freed_gb\":$cache_freed},"
            fi
            
            # Supprimer les anciens logs (7 jours)
            if [[ "$dry_run" == "false" ]]; then
                local log_size_before=$(du -sg ~/Library/Logs 2>/dev/null | awk '{print $1}' || echo "0")
                find ~/Library/Logs -type f -mtime +7 -delete 2>/dev/null
                local log_size_after=$(du -sg ~/Library/Logs 2>/dev/null | awk '{print $1}' || echo "0")
                local log_freed=$((log_size_before - log_size_after))
                total_freed=$((total_freed + log_freed))
                operations="$operations{\"operation\":\"remove_old_logs\",\"freed_gb\":$log_freed},"
            fi
            
            # Vider la corbeille
            if [[ "$dry_run" == "false" ]]; then
                local trash_size=$(du -sg ~/.Trash 2>/dev/null | awk '{print $1}' || echo "0")
                rm -rf ~/.Trash/*
                total_freed=$((total_freed + trash_size))
                operations="$operations{\"operation\":\"empty_trash\",\"freed_gb\":$trash_size},"
            fi
            ;;
            
        "development_optimized")
            # Vider les données dérivées Xcode
            if [[ -d ~/Library/Developer/Xcode/DerivedData && "$dry_run" == "false" ]]; then
                local derived_size=$(du -sg ~/Library/Developer/Xcode/DerivedData 2>/dev/null | awk '{print $1}' || echo "0")
                rm -rf ~/Library/Developer/Xcode/DerivedData/*
                total_freed=$((total_freed + derived_size))
                operations="$operations{\"operation\":\"clear_xcode_derived_data\",\"freed_gb\":$derived_size},"
            fi
            
            # Vider les données du simulateur iOS
            if [[ -d ~/Library/Developer/CoreSimulator && "$dry_run" == "false" ]]; then
                local sim_size_before=$(du -sg ~/Library/Developer/CoreSimulator 2>/dev/null | awk '{print $1}' || echo "0")
                xcrun simctl delete unavailable
                local sim_size_after=$(du -sg ~/Library/Developer/CoreSimulator 2>/dev/null | awk '{print $1}' || echo "0")
                local sim_freed=$((sim_size_before - sim_size_after))
                total_freed=$((total_freed + sim_freed))
                operations="$operations{\"operation\":\"cleanup_simulator_data\",\"freed_gb\":$sim_freed},"
            fi
            ;;
    esac
    
    # Supprimer la virgule finale
    operations="${operations%,}"
    
    # Créer un rapport de nettoyage
    cat > "$cleanup_report" << EOF
{
  "cleanup_report": {
    "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "policy": "$cleanup_policy",
    "dry_run": "$dry_run",
    "total_freed_gb": $total_freed,
    "operations": [$operations]
  },
  "storage_after_cleanup": {
    "available_space": "$(df -h / | awk 'NR==2 {print $4}')",
    "usage_percentage": "$(df -h / | awk 'NR==2 {print $5}')"
  }
}
EOF
    
    if [[ "$dry_run" == "false" ]]; then
        log_action "Nettoyage terminé. Espace total libéré : ${total_freed}GB"
    else
        log_action "Test à blanc terminé. Libérerait approximativement : ${total_freed}GB"
    fi
    
    echo "$cleanup_report"
}

# Surveillance et alerte de stockage
monitor_storage_continuously() {
    local monitoring_interval="${1:-300}"  # 5 minutes par défaut
    local alert_threshold="${2:-10}"       # 10GB par défaut
    
    log_action "Démarrage de la surveillance continue de stockage (intervalle : ${monitoring_interval}s, seuil : ${alert_threshold}GB)"
    
    while true; do
        local available_gb=$(df -g / | awk 'NR==2 {print $4}')
        local usage_percent=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
        
        if [[ $available_gb -lt $alert_threshold ]]; then
            log_action "ALERTE STOCKAGE : Seulement ${available_gb}GB restants (${usage_percent}% utilisés)"
            
            # Envoyer notification système
            osascript -e "display notification \"Stockage faible : ${available_gb}GB restants\" with title \"Moniteur Stockage Roundfleet\""
            
            # Optionnellement déclencher le nettoyage automatique
            if [[ $available_gb -lt 5 ]]; then
                log_action "Déclenchement du nettoyage d'urgence..."
                perform_storage_cleanup "aggressive_cleanup" "false"
            fi
        fi
        
        # Enregistrer le statut actuel
        log_action "Statut stockage : ${available_gb}GB disponible (${usage_percent}% utilisé)"
        
        sleep "$monitoring_interval"
    done
}

# Fonction d'exécution principale
main() {
    create_directories
    
    case "${1:-}" in
        "analyze")
            analyze_storage_comprehensive "${2:-standard}"
            ;;
        "cleanup")
            perform_storage_cleanup "${2:-conservative_cleanup}" "${3:-false}"
            ;;
        "monitor")
            monitor_storage_continuously "${2:-300}" "${3:-10}"
            ;;
        "help"|*)
            echo "Système de Gestion de Stockage d'Entreprise Roundfleet"
            echo ""
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  analyze [niveau]                     - Analyser le stockage (basic|standard|detailed|full)"
            echo "  cleanup <politique> [dry_run]       - Effectuer nettoyage (aggressive_cleanup|conservative_cleanup|development_optimized|media_optimized) [true|false]"
            echo "  monitor [intervalle] [seuil]         - Surveillance continue (intervalle en secondes, seuil en GB)"
            echo ""
            echo "Exemples :"
            echo "  $0 analyze detailed"
            echo "  $0 cleanup aggressive_cleanup false"
            echo "  $0 monitor 600 15"
            ;;
    esac
}

# Exécuter la fonction principale
main "$@"

## Analyse et Surveillance de Stockage

Le système d'entreprise fournit une analyse complète de stockage :

| **Niveau d'Analyse** | **Portée** | **Détails** | **Cas d'Usage** |
|---|---|---|---|
| **Basic** | Utilisation globale du disque | Vérification rapide d'espace | Surveillance quotidienne |
| **Standard** | Répartition utilisateur et système | Modèles d'utilisation détaillés | Révisions hebdomadaires |
| **Detailed** | Analyse des grands répertoires | Inventaire complet | Audits mensuels |
| **Full** | Analyse complète du système | Rapports d'entreprise | Évaluations trimestrielles |

## Politiques de Nettoyage de Stockage

### Politique de Nettoyage Agressive

```bash
# Effectuer nettoyage agressif pour récupérer un maximum d'espace
./storage_manager.sh cleanup aggressive_cleanup false

# Test à blanc pour voir ce qui serait nettoyé
./storage_manager.sh cleanup aggressive_cleanup true

Nettoyage Optimisé pour le Développement

# Nettoyer les caches et données de build spécifiques au développement
./storage_manager.sh cleanup development_optimized false

Surveillance de Stockage d'Entreprise

Surveillance Continue

# Surveiller le stockage toutes les 5 minutes avec seuil de 10GB
./storage_manager.sh monitor 300 10

# Surveiller le stockage chaque heure avec seuil de 20GB
./storage_manager.sh monitor 3600 20

Alertes Automatisées

Le système fournit des alertes intelligentes :

• Alerte Critique - Moins de 5GB restants
• Alerte d'Avertissement - Moins de 10GB restants
• Stockage Faible - Moins de 20GB restants
• Optimal - Plus de 50GB restants

Considérations Importantes de Stockage

• Chiffrement FileVault doit être activé pour la sécurité d'entreprise
• Sauvegardes Time Machine nécessitent un stockage externe adéquat
• Instantanés APFS consomment du stockage et doivent être surveillés
• Caches d'application peuvent grossir et nécessitent un nettoyage régulier
• Éducation des utilisateurs aide à maintenir une utilisation optimale du stockage

Conformité et Gouvernance

Le système d'entreprise supporte diverses frameworks de conformité :

• Conformité GDPR - Rétention de données et suppression sécurisée
• Exigences HIPAA - Sécurité de stockage de données de santé
• Conformité SOX - Contrôles de stockage de données financières
• ISO 27001 - Gestion de sécurité de stockage d'information

Ce système complet transforme les commandes de base d'utilisation du disque en une plateforme de gestion de stockage de niveau entreprise avec surveillance avancée, optimisation automatisée et capacités de gestion de flotte.

Stage Manager est une fonctionnalité puissante de gestion des fenêtres introduite dans macOS Ventura qui aide les utilisateurs à organiser et se concentrer sur leur travail en regroupant les fenêtres et en masquant les applications inactives. Ce tutoriel vous montre comment gérer les paramètres de Stage Manager dans votre flotte Mac à l'aide de scripts shell.

Qu'est-ce que Stage Manager ?

Stage Manager est un système de gestion de fenêtres qui :

• Organise les fenêtres en groupes focalisés sur le bureau
• Réduit l'encombrement visuel en masquant les applications inactives
• Améliore la productivité en permettant aux utilisateurs de basculer entre différents contextes de travail
• Prend en charge les écrans externes avec des contrôles Stage Manager indépendants
• S'intègre avec Mission Control pour une gestion améliorée des fenêtres

Prérequis et compatibilité

Configuration système requise

• macOS 13.0 (Ventura) ou ultérieur - Stage Manager n'est pas disponible sur les versions antérieures
• Appareils pris en charge : Ordinateurs Mac avec Apple Silicon (M1, M2, M3, M4) ou processeurs Intel
• Privilèges administrateur pour l'exécution de scripts

Compatibilité matérielle

Stage Manager fonctionne mieux sur :

• MacBook Pro et MacBook Air (2018 ou ultérieur)
• iMac (2019 ou ultérieur)
• Mac Studio (tous les modèles)
• Mac Pro (2019 ou ultérieur)
• Mac Mini (2018 ou ultérieur)

Gestion de base de Stage Manager

Activer Stage Manager

#!/bin/bash

# Script pour activer Stage Manager sur macOS
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

echo "Activation de Stage Manager Roundfleet"
echo "Utilisateur actuel : $CurrentUser"
echo "UID de l'utilisateur actuel : $CurrentUserUID"

# Activer Stage Manager globalement
launchctl asuser $CurrentUserUID sudo -iu "$CurrentUser" defaults write com.apple.WindowManager GloballyEnabled -bool true

echo "✅ Stage Manager a été activé pour l'utilisateur $CurrentUser"
echo "Les changements prendront effet après la prochaine connexion ou le redémarrage du gestionnaire de fenêtres"

Désactiver Stage Manager

#!/bin/bash

# Script pour désactiver Stage Manager sur macOS
CurrentUser=$(ls -l /dev/console | awk '/ / { print $3 }')
CurrentUserUID=$(id -u "$CurrentUser")

echo "Désactivation de Stage Manager Roundfleet"
echo "Utilisateur actuel : $CurrentUser"
echo "UID de l'utilisateur actuel : $CurrentUserUID"

# Désactiver Stage Manager globalement
launchctl asuser $CurrentUserUID sudo -iu "$CurrentUser" defaults write com.apple.WindowManager GloballyEnabled -bool false

echo "❌ Stage Manager a été désactivé pour l'utilisateur $CurrentUser"
echo "Les changements prendront effet après la prochaine connexion ou le redémarrage du gestionnaire de fenêtres"

Configuration avancée de Stage Manager

Script de gestion complet de Stage Manager

#!/bin/bash

# Gestion avancée de Stage Manager pour flotte Mac
DEVICE_NAME=$(scutil --get ComputerName)
CURRENT_USER=$(ls -l /dev/console | awk '/ / { print $3 }')
CURRENT_USER_UID=$(id -u "$CURRENT_USER")
MACOS_VERSION=$(sw_vers -productVersion)
LOG_FILE="/var/log/roundfleet_stage_manager.log"

# Fonction pour enregistrer les messages
log_message() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Fonction pour vérifier la compatibilité de la version macOS
check_compatibility() {
    local major_version=$(echo "$MACOS_VERSION" | cut -d. -f1)
    local minor_version=$(echo "$MACOS_VERSION" | cut -d. -f2)
    
    if [ "$major_version" -ge 13 ]; then
        echo "✅ macOS $MACOS_VERSION est compatible avec Stage Manager"
        return 0
    else
        echo "❌ macOS $MACOS_VERSION n'est pas compatible avec Stage Manager (nécessite 13.0+)"
        return 1
    fi
}

# Fonction pour obtenir le statut actuel de Stage Manager
get_stage_manager_status() {
    local status=$(launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults read com.apple.WindowManager GloballyEnabled 2>/dev/null)
    case "$status" in
        1) echo "activé" ;;
        0) echo "désactivé" ;;
        *) echo "indéfini" ;;
    esac
}

# Fonction pour activer Stage Manager
enable_stage_manager() {
    launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults write com.apple.WindowManager GloballyEnabled -bool true
    log_message "Stage Manager activé sur $DEVICE_NAME pour l'utilisateur $CURRENT_USER"
}

# Fonction pour désactiver Stage Manager
disable_stage_manager() {
    launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults write com.apple.WindowManager GloballyEnabled -bool false
    log_message "Stage Manager désactivé sur $DEVICE_NAME pour l'utilisateur $CURRENT_USER"
}

# Fonction pour configurer la visibilité des applications récentes
configure_recent_apps() {
    local show_recent="$1"
    
    if [ "$show_recent" = "true" ]; then
        launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults write com.apple.WindowManager AutoHide -bool false
        log_message "Visibilité des applications récentes activée"
        echo "✅ Les applications récentes seront visibles sur le côté gauche"
    else
        launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults write com.apple.WindowManager AutoHide -bool true
        log_message "Visibilité des applications récentes désactivée"
        echo "❌ Les applications récentes seront masquées"
    fi
}

# Fonction pour configurer le comportement de regroupement des fenêtres
configure_window_grouping() {
    local grouping_mode="$1"
    
    case "$grouping_mode" in
        "all_at_once")
            launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults write com.apple.WindowManager AppWindowGroupingBehavior -bool false
            log_message "Regroupement de fenêtres défini sur 'Toutes à la fois'"
            echo "✅ Regroupement de fenêtres : Toutes à la fois"
            ;;
        "one_at_time")
            launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" defaults write com.apple.WindowManager AppWindowGroupingBehavior -bool true
            log_message "Regroupement de fenêtres défini sur 'Une à la fois'"
            echo "✅ Regroupement de fenêtres : Une à la fois"
            ;;
        *)
            echo "❌ Mode de regroupement invalide. Utilisez 'all_at_once' ou 'one_at_time'"
            return 1
            ;;
    esac
}

# Fonction pour redémarrer le gestionnaire de fenêtres
restart_window_manager() {
    launchctl asuser $CURRENT_USER_UID sudo -iu "$CURRENT_USER" killall WindowManager 2>/dev/null
    sleep 2
    log_message "Gestionnaire de fenêtres redémarré pour l'utilisateur $CURRENT_USER"
}

# Fonction pour valider la configuration de Stage Manager
validate_configuration() {
    local expected_state="$1"
    local current_state=$(get_stage_manager_status)
    
    if [ "$current_state" = "$expected_state" ]; then
        echo "✅ Validation de la configuration réussie : Stage Manager est $expected_state"
        return 0
    else
        echo "❌ Échec de la validation de la configuration : Attendu $expected_state, obtenu $current_state"
        return 1
    fi
}

# Exécution principale
echo "Configuration de Stage Manager Roundfleet"
echo "======================================"
echo "Appareil : $DEVICE_NAME"
echo "Utilisateur : $CURRENT_USER"
echo "Version macOS : $MACOS_VERSION"
echo ""

log_message "Début de la configuration de Stage Manager sur $DEVICE_NAME"

# Vérifier la compatibilité
if ! check_compatibility; then
    log_message "Configuration de Stage Manager abandonnée en raison de problèmes de compatibilité"
    exit 1
fi

# Afficher le statut actuel
echo "Statut actuel de Stage Manager : $(get_stage_manager_status)"
echo ""

# Options de configuration (décommentez selon les besoins)
# enable_stage_manager
# disable_stage_manager
# configure_recent_apps "true"
# configure_window_grouping "all_at_once"
# restart_window_manager

log_message "Configuration de Stage Manager terminée"