{"meta":{"title":"Paramètres gérés par l’entreprise","intro":"Comprendre le schéma des paramètres gérés d’entreprise utilisé par les clients Copilot.","product":"GitHub Copilot","breadcrumbs":[{"href":"/fr/enterprise-cloud@latest/copilot","title":"GitHub Copilot"},{"href":"/fr/enterprise-cloud@latest/copilot/reference","title":"Informations de référence"},{"href":"/fr/enterprise-cloud@latest/copilot/reference/enterprise-administrators","title":"Administrateurs d’entreprise"},{"href":"/fr/enterprise-cloud@latest/copilot/reference/enterprise-administrators/enterprise-managed-settings","title":"Paramètres gérés par l’entreprise"}],"documentType":"article"},"body":"# Paramètres gérés par l’entreprise\n\nComprendre le schéma des paramètres gérés d’entreprise utilisé par les clients Copilot.\n\nUtilisez cette référence pour comprendre les clés actuellement prises en charge dans `managed-settings.json`.\n\nPour connaître les méthodes de déploiement et les clients pris en charge, consultez [Configuration des paramètres gérés par l’entreprise](/fr/enterprise-cloud@latest/copilot/how-tos/administer-copilot/manage-for-enterprise/manage-agents/configure-enterprise-managed-settings).\n\n## Règles de précédence\n\nLorsque plusieurs sources de paramètres sont présentes, les paramètres antérieurs à cette liste sont prioritaires sur les paramètres plus loin dans la liste :\n\n1. Paramètres gérés par MDM\n2. Paramètres gérés par le serveur\n3. Paramètres basés sur des fichiers\n4. Paramètres au niveau de l’utilisateur\n\nÀ titre d’exception, les clés suivantes sont composées dans la direction la plus restrictive entre différentes méthodes de remise :\n\n* `sandbox`\n* `permissions.deny`, `permissions.ask` et `permissions.allow`\n\n## Clés prises en charge\n\n
\n\n| Clé | Purpose | Copilot CLI | VS Code | GitHub Copilot app | Copilot cloud agent | JetBrains IDEs |\n| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `permissions.disableBypassPermissionsMode` | Désactive le contournement ou le comportement de type YOLO autorisant tout. | | | | | |\n| `permissions.deny` | Bloque des opérations spécifiques | | | | | |\n| `permissions.ask` | Nécessite une nouvelle approbation humaine avant que des opérations spécifiques puissent continuer | | | | | |\n| `permissions.allow` | Autorise les opérations spécifiques à continuer sans invite | | | | | |\n| `model` | Définit la sélection automatique du modèle comme valeur par défaut pour les nouvelles conversations | | | | | |\n| `enabledPlugins` | Active ou désactive des plug-ins spécifiques par clé | | | | | |\n| `extraKnownMarketplaces` | Ajoute des places de marché de plug-in auxquelles les utilisateurs peuvent accéder | | | | | |\n| `strictKnownMarketplaces` | Limite l’installation du plug-in aux places de marché répertoriées explicitement | | | | | |\n| `telemetry` | Configure l’export OpenTelemetry et le routage des données d’utilisation Copilot vers le collecteur de votre choix | | | | | |\n| `remoteControl` | Limite la possibilité que les sessions hébergées sur cet appareil soient contrôlées à distance, en fonction du statut d’autorisation SSO du client de contrôle pour les organisations répertoriées. N’affecte pas la capacité de l’utilisateur à contrôler à distance les sessions hébergées sur d’autres appareils | | | | | |\n| `allowedMcpServers` | Définit une liste d’autorisation des serveurs MCP autorisés à être exécutés. Tout serveur qui ne correspond à aucune règle est bloqué. Omettre d’autoriser tous les serveurs, soumis à des règles de refus | | | | | |\n| `deniedMcpServers` | Définit les serveurs MCP qui sont bloqués sans condition, même s’ils correspondent également à une entrée dans `allowedMcpServers` | | | | | |\n| `sandbox` | Applique les restrictions minimales de bac à sable local pour l’exécution des commandes, le système de fichiers et l’accès réseau, les informations d’identification et les serveurs MCP et LSP locaux | | | | | |\n\n
\n\n## Application de différents paramètres aux équipes d’entreprise\n\nPour les déploiements gérés par le serveur, l’entreprise peut appliquer une gouvernance différente aux groupes d’utilisateurs en fonction de leur appartenance à l’équipe d’entreprise. L’entreprise définit tous les paramètres : l’appartenance à l’équipe détermine uniquement les utilisateurs qui reçoivent un ensemble de valeurs donné.\n\nPour rendre une clé éligible pour les valeurs spécifiques à l’équipe, marquez-la comme substituable dans `managed-settings.json` à l’aide de la syntaxe `{ \"overridable\": }`. Une clé redéfinissable utilise la valeur de l’équipe lorsqu’une valeur est définie, ou utilise la valeur par défaut de votre entreprise lorsque l’équipe n’en définit pas. La syntaxe `{ \"overridable\": }` s’applique aux touches `model`, `permissions.allow`, `permissions.ask`, `allowedMcpServers`, `permissions.disableBypassPermissionsMode`, `permissions.deny` et `deniedMcpServers`. Les clés non marquées comme substituables restent une décision au niveau de l’entreprise que les équipes ne peuvent pas modifier.\n\n`enabledPlugins` et `extraKnownMarketplaces` fonctionnent de façon additive. L’entreprise `managed-settings.json` définit une base de référence et un fichier d’équipe d’entreprise peut ajouter d’autres plug-ins et des places de marché. Pour connaître les étapes d’installation complètes, consultez [Configuration des paramètres gérés par l’entreprise](/fr/enterprise-cloud@latest/copilot/how-tos/administer-copilot/manage-for-enterprise/manage-agents/configure-enterprise-managed-settings#overriding-settings-for-specific-teams).\n\n## Exemple de configuration\n\nL’exemple suivant montre ces clés dans un fichier de paramètres managés.\n\n```json\n{\n \"model\": \"auto\",\n \"permissions\": {\n \"disableBypassPermissionsMode\": \"disable\",\n \"deny\": [\n \"Shell(rm -rf *)\",\n \"Read(~/.ssh/**)\",\n \"Edit(//etc/**)\",\n \"Domain(*.unapproved.example)\"\n ],\n \"ask\": [\n \"Shell(git push *)\",\n \"Edit(/src/**)\",\n \"Domain(api.github.com)\"\n ],\n \"allow\": [\n \"Shell(npm test *)\",\n \"Read(/src/**)\",\n \"Domain(registry.npmjs.org)\"\n ]\n },\n \"enabledPlugins\": {\n \"my-plugin@agent-skills\": true\n },\n \"extraKnownMarketplaces\": {\n \"agent-skills\": {\n \"source\": {\n \"source\": \"github\",\n \"repo\": \"OWNER/REPO\"\n },\n \"autoUpdate\": true\n }\n },\n \"strictKnownMarketplaces\": [\n {\n \"source\": \"github\",\n \"repo\": \"OWNER/REPO\"\n }\n ],\n \"telemetry\": {\n \"enabled\": true,\n \"endpoint\": \"https://otel-collector.example.com\",\n \"protocol\": \"http/protobuf\",\n \"captureContent\": false,\n \"lockCaptureContent\": true,\n \"serviceName\": \"copilot\",\n \"resourceAttributes\": {\n \"deployment.environment\": \"production\"\n },\n \"headers\": {\n \"Authorization\": \"Bearer TOKEN\"\n }\n },\n \"remoteControl\": {\n \"mode\": \"requireSSO\",\n \"githubDotComOrganizations\": [\"ORG-NAME\"]\n },\n \"allowedMcpServers\": [\n { \"serverUrl\": \"https://api.githubcopilot.com/*\" },\n { \"serverCommand\": [\"npx\", \"@playwright/mcp@latest\"] },\n { \"serverCommand\": [\"cmd\", \"/c\", \"uvx\", \"markitdown-mcp\"] }\n ],\n \"deniedMcpServers\": [\n {\n \"serverCommand\": [\n \"npx\",\n \"-y\",\n \"@modelcontextprotocol/server-filesystem\",\n \"/\"\n ]\n }\n ],\n \"sandbox\": {\n \"enabled\": true,\n \"allowBypass\": false,\n \"sandboxMcpServers\": true,\n \"sandboxLspServers\": true\n }\n}\n```\n\n## extensions activées\n\nDéfinit les plug-ins qui sont automatiquement installés ou bloqués pour tous les utilisateurs d’entreprise. Chaque entrée utilise le format `PLUGIN-NAME@MARKETPLACE-NAME` comme clé, avec une valeur booléenne : `true` pour exiger que le plug-in soit activé ou `false` qu’il soit désactivé. Consultez « [À propos des normes de plug-in gérés par l’entreprise](/fr/enterprise-cloud@latest/copilot/concepts/agents/about-enterprise-plugin-standards) ».\n\n## extraKnownMarketplaces\n\nDéfinit des places de marché de plug-in supplémentaires disponibles pour les utilisateurs. Chaque entrée est un objet marketplace nommé contenant une `source` propriété et une valeur booléenne facultative `autoUpdate` .\n\nDéfinissez `true` sur `autoUpdate` pour exiger que les clients actualisent régulièrement cette marketplace et mettent à jour les plug-ins installés qui en sont issus. Définissez cette option sur `false` pour exiger que les mises à jour automatiques restent désactivées pour cette place de marché. Si vous omettez `autoUpdate`, les clients utilisent leur comportement par défaut ou configuré par l’utilisateur existant.\n\nÉtant donné que les paramètres managés sont prioritaires, les utilisateurs ne peuvent pas remplacer une valeur définie `autoUpdate` . Le paramètre s’applique uniquement à cette place de marché, et toutes les restrictions dans `strictKnownMarketplaces` s’appliquent toujours avant les opérations d’actualisation et de mise à jour.\n\nLes types sources suivants sont pris en charge :\n\n* `\"github\"` — nécessite `repo` au format `OWNER/REPO` ; avec en option `ref` (branche, balise ou SHA) et `path` (sous-répertoire)\n* `\"git\"` — exige `url`; facultatif `ref` et `path`\n* `\"directory\"` — nécessite `path`\n\nConsultez « [À propos des normes de plug-in gérés par l’entreprise](/fr/enterprise-cloud@latest/copilot/concepts/agents/about-enterprise-plugin-standards) ».\n\n## strictKnownMarketplaces\n\nLimite l’installation du plug-in aux places de marché définies explicitement par l’entreprise. Un tableau vide correspond à un verrouillage complet. Chaque entrée est un objet marketplace avec une `source` propriété indiquant le type source. Les types sources suivants sont pris en charge :\n\n* `\"github\"` — nécessite `repo` au format `OWNER/REPO` ; `ref` et `path` facultatifs\n* `\"git\"` — exige `url`; facultatif `ref` et `path`\n* `\"url\"`— nécessite `url`; objet facultatif `headers`\n* `\"npm\"` — nécessite `package`\n* `\"file\"` — nécessite `path`\n* `\"directory\"` — nécessite `path`\n* `\"hostPattern\"` — nécessite `hostPattern` (expression régulière correspondant aux hôtes de la marketplace)\n* `\"pathPattern\"` — nécessite `pathPattern` (expression régulière correspondant aux chemins de la marketplace)\n\n## modèle\n\nDéfinit la sélection automatique du modèle comme valeur par défaut pour les nouvelles conversations. Consultez « [À propos de Copilotauto model selection](/fr/enterprise-cloud@latest/copilot/concepts/models/auto-model-selection) ».\n\n* Lorsque vous définissez `model` sur `\"auto\"`, les nouvelles sessions utilisent le modèle Auto, sauf si l’utilisateur spécifie un modèle différent pour chaque conversation.\n* Cette clé est substituable par le mappage d’équipe d’entreprise. Dans votre `managed-settings.json`, utilisez la syntaxe `{ \"overridable\": \"auto\" }` pour personnaliser la configuration de la clé pour chaque équipe. Vous pouvez ensuite définir `\"model\": \"unmanaged\"` dans un fichier de paramètres d’équipe, en fournissant une spécialisation qui prévaut sur `managed-settings.json` pour les membres de l’équipe concernée.\n\n> \\[!NOTE]\n> `model` a été documenté à l’origine comme `permissions.model`. Les clients lisent toujours la valeur imbriquée `permissions.model` lorsque la clé de niveau `model` supérieur est absente, mais vous devez utiliser la clé de niveau `model` supérieur dans les nouvelles configurations.\n\n## permissions\n\n### refuser, demander, autoriser\n\nLes clés `permissions.deny`, `permissions.allow` et `permissions.ask` suivent l’ordre de priorité **refuser > demander > autoriser**. Si une source gérée par MDM, gérée par serveur ou basée sur des fichiers définit une règle d’autorisation, ou si une source applicable déclare une liste `allow`, une opération prise en charge sans correspondance nécessite par défaut une approbation. Sinon, il suit le processus d’autorisation habituel.\n\n* `deny` bloque des opérations spécifiques, qu’elles correspondent ou non à une règle `ask` ou `allow`. Une règle de refus définie par n’importe quelle source de paramètres managés bloque l’opération pour tous les utilisateurs, quelles que soient les règles des autres sources.\n* `ask` nécessite une nouvelle approbation ponctuelle avant qu’une opération spécifique puisse continuer, même si l’opération serait autorisée. Une règle gérée `ask` ne peut pas être respectée via le mode de contournement (également appelé mode « tout autoriser » ou mode YOLO), un paramètre d’approbation automatique, un déclencheur ou un autre raccourci d’approbation, ni via une autorisation conservée à la suite d’une approbation antérieure. La même opération redemande une confirmation la prochaine fois qu’elle est demandée.\n* `allow` autorise une opération donnée sans invite. La liste d’autorisation effective est l’intersection de toutes les sources qui en déclarent une, et non pas l’union. Une source qui ne déclare pas de liste `allow` n’impose elle-même aucune restriction à cette clé.\n\nLes règles utilisent les sélecteurs suivants :\n\n| Selector | Correspondances |\n| -------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `Shell(...)` | Commandes Shell. Utilisez ` *` (par exemple) `git push *`pour faire correspondre un préfixe de commande ; sinon, la règle correspond au texte exact. |\n| `Bash(...)` est un alias de compatibilité pour `Shell(...)`. | |\n| `PowerShell(...)` utilise la même famille de sélecteurs avec une correspondance insensible à la casse des commandes. | |\n| `Read(...)` | Chemins de lecture et d’affichage des fichiers. Prend en charge les modèles glob et ces racines : `//` pour la racine du système de fichiers, `/` pour la racine de l’espace de travail, `~/` pour le répertoire de base et `./` pour le répertoire de travail actuel. |\n| `Edit(...)` | Les chemins d’écriture et de modification de fichier correspondent à la même façon que `Read(...)`. |\n| `Write(...)` est un alias pour `Edit(...)`. | |\n| `Domain(...)` | Origines du réseau. Un hôte sans schéma utilise HTTPS par défaut, et la correspondance de l’hôte est insensible à la casse. Permet `*.` d’inclure des sous-domaines ; par exemple, `*.example.com` correspond à example.com et à ses sous-domaines. |\n\nChaque sous-clé peut être redéfinie pour les équipes d’entreprise. Définissez la valeur d’entreprise sur `{ \"overridable\": }`, en remplaçant `` par le tableau de règles. Utilisez ensuite la syntaxe régulière pour définir des règles de remplacement dans le fichier de chaque équipe.\n\n### disableBypassPermissionsMode\n\nEmpêche les utilisateurs d’activer le mode de contournement (également appelé « mode YOLO »). Le mode contournement permet à un agent d’exécuter des commandes, d’accéder aux fichiers et d’extraire des URL sans demander d’approbation.\n\nLorsque vous définissez `disableBypassPermissionsMode` sur `\"disable\"`, les utilisateurs ne peuvent pas activer le mode de contournement :\n\n* Dans Copilot CLI, toutes les options de ligne de commande permettant d’accorder toutes les autorisations (`--yolo`, `--allow-all` et les options individuelles `--allow-all-tools`, `--allow-all-paths` et `--allow-all-urls`) sont désactivées au démarrage et ne peuvent pas accorder d’autorisations étendues. Les commandes slash `/yolo` et `/allow-all` sont également bloquées.\n* Dans VS Code, le paramètre global d’approbation automatique (`chat.tools.global.autoApprove`) est désactivé et ne peut pas être réactivé.\n* Dans le GitHub Copilot app, le paramètre « Tout autoriser » de « Autorisations de l’outil » est bloqué dans les paramètres de session.\n* Cette clé est substituable par le mappage d’équipe d’entreprise. Dans votre `managed-settings.json`, utilisez la syntaxe `{ \"overridable\": \"disable\" }` pour personnaliser la configuration de la clé pour chaque équipe. Vous pouvez ensuite définir `\"disableBypassPermissionsMode\": \"unmanaged\"` dans un fichier de paramètres d’équipe, en fournissant une spécialisation qui prévaut sur `managed-settings.json` pour les membres de l’équipe concernée.\n\n## données de télémétrie\n\nConfigure l’exportation OpenTelemetry et le routage Copilot des données d’utilisation vers le collecteur de votre choix.\n\nCette propriété est prise en charge pour Copilot CLI et VS Code.\n\nLorsque vous définissez la propriété `telemetry`, la télémétrie Copilot est envoyée au point de terminaison que vous spécifiez. Les sous-propriétés suivantes sont prises en charge :\n\n* `enabled`: définissez sur `true` pour activer l’exportation de télémétrie, ou sur `false` pour la désactiver.\n* `endpoint`: URL de votre collecteur OTLP (par exemple, `https://otel-collector.example.com`).\n* `protocol`: protocole de transport pour l’exportation de télémétrie. Les valeurs acceptées sont `\"http/json\"` et `\"http/protobuf\"`.\n* `captureContent` : définissez cette valeur sur `true` pour inclure le contenu des invites et des réponses dans la charge utile de télémétrie, ou sur `false` pour l’exclure.\n* `lockCaptureContent`: défini sur `true` pour empêcher les utilisateurs de modifier le paramètre `captureContent`.\n* `serviceName`: étiquette pour le nom du service de télémétrie (par exemple, `\"copilot\"`).\n* `resourceAttributes`: objet d’attributs de ressource OpenTelemetry à attacher à toutes les données de télémétrie exportées (par exemple, `{\"deployment.environment\": \"production\"}`).\n* `headers`: Un objet d’en-têtes HTTP à inclure avec chaque requête de télémétrie (par exemple, un en-tête `Authorization` pour votre collecteur).\n\n## remoteControl\n\nLimite si Copilot les sessions hébergées sur un appareil peuvent être contrôlées à distance. Cela n’affecte pas la capacité d’un utilisateur à contrôler à distance ses sessions hébergées sur d’autres appareils.\n\n* `mode`: défini pour `\"disabled\"` empêcher le contrôle à distance des sessions sur l’appareil, `\"requireSSO\"` pour autoriser uniquement le contrôle à distance d’un client autorisé par l’authentification unique pour les organisations répertoriées dans `githubDotComOrganizations`, ou `\"enabled\"` pour l’autoriser sans restriction.\n* `githubDotComOrganizations`: Un tableau d’identifiants de connexion de l’organisation. Obligatoire quand `mode` est `\"requireSSO\"`.\n\n## allowedMcpServers\n\nDéfinit une liste d’autorisation des serveurs MCP autorisés à être exécutés. Quand il est défini, seuls les serveurs correspondant à au moins une entrée sont autorisés. Tout serveur qui n’est pas mis en correspondance est bloqué.\n\nOmettez entièrement cette clé pour autoriser tous les serveurs, sous réserve des entrées dans `deniedMcpServers`. Définissez-le sur un tableau vide pour bloquer tous les serveurs, à l’exception des serveurs par défaut intégrés.\n\nLorsque plusieurs sources de paramètres définissent `allowedMcpServers`, la liste d’autorisation effective est l’intersection de l’ensemble des sources. Un serveur doit être autorisé par chaque source à s’exécuter.\n\nChaque entrée doit contenir exactement une seule propriété de correspondance.\n\n| Propriété | Comportement de mise en correspondance | Serveurs applicables |\n| --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `serverName` | Correspond exactement à l’étiquette de serveur affectée par l’utilisateur. Les caractères génériques ne sont pas pris en charge. Étant donné que les utilisateurs choisissent des noms de serveur, utilisez `serverUrl` ou `serverCommand` lorsque vous devez appliquer l’identité d’un serveur. | N’importe quel serveur. Les serveurs en mémoire peuvent uniquement utiliser `serverName`. |\n| `serverUrl` | Correspond à une URL de serveur distant. Prend en charge les caractères génériques `*` pour les sous-domaines ou les préfixes de chemin, par exemple `https://mcp.example.com/*` ou `https://*.internal.example.com/*`. | Serveurs distants qui se connectent via des événements HTTP ou envoyés par un serveur (SSE). Cette propriété ne s’applique pas aux serveurs locaux, même s’ils ont une URL. |\n| `serverCommand` | Correspond à la commande exacte et à chaque argument d’un serveur local, par exemple `[\"npx\", \"-y\", \"my-mcp-server\"]`. Les caractères génériques et l’expansion de la ligne de commande ne sont pas pris en charge. | Serveurs locaux qui utilisent l’entrée et la sortie standard (`stdio`). Cette propriété ne s’applique pas aux serveurs distants, même s’ils ont une commande. |\n\nCette clé peut être redéfinie pour les équipes d’entreprise. Encapsulez les objets de correspondance sous `overridable` au niveau de l’entreprise, puis utilisez la syntaxe habituelle pour définir les listes d’autorisation et les listes de blocage dans le fichier de chaque équipe.\n\n### Canonisation d’URL\n\nAvant de comparer un `serverUrl` modèle avec une URL de serveur, le client normalise les deux valeurs :\n\n* Convertit le schéma et l’hôte en minuscules.\n* Convertit les noms d’hôtes internationalisés ou Unicode en Punycode.\n* Supprime le port par défaut, `:80` pour HTTP ou `:443` https.\n* Décode les octets du composant hôte codés en pourcentage. Par exemple, `%65vil` devient `evil`.\n* Supprime les fragments d’URL et les points finaux des noms DNS.\n* Empêche les caractères génériques dans le composant d’autorité de correspondre sur la délimitation `/` dans le chemin d’accès.\n\n## deniedMcpServers\n\nDéfinit les serveurs MCP qui sont bloqués sans condition. Un serveur correspondant à une entrée est bloqué même s’il correspond également à une entrée dans `allowedMcpServers`. Les règles de refus sont toujours prioritaires sur les règles d’autorisation.\n\nLes Copilot serveurs internes, tels que le serveur MCP intégré GitHub , sont exemptés des règles de refus et ne peuvent pas être bloqués.\n\nLorsque plusieurs sources de paramètres définissent `deniedMcpServers`, la liste de refus effective est l’union de toutes les sources. Un serveur bloqué par n’importe quelle source est bloqué pour tous.\n\nChaque entrée utilise les mêmes propriétés `serverName`, `serverUrl` ou `serverCommand` décrites dans `allowedMcpServers`.\n\n## `sandbox`\n\nApplique les restrictions minimales de bac à sable local pour Copilot CLI. Les paramètres de bac à sable managé imposent des restrictions plutôt que des valeurs par défaut :\n\n* Pour les paramètres d’activation forcée, une valeur gérée de `true` applique ce paramètre.\n `false` ou une omission laisse la configuration utilisateur inchangée.\n* Pour les paramètres de fonctionnalité, une valeur gérée de `false` interdit la fonctionnalité.\n `true` ou une omission laisse la configuration utilisateur inchangée.\n* Les listes de chemins d’accès en lecture/écriture managée et en lecture seule limitent les octrois configurés par l’utilisateur, tandis que les chemins d’accès gérés refusés s’ajoutent aux dénis configurés par l’utilisateur.\n\nLes sous-propriétés suivantes sont prises en charge :\n\n* `enabled`: `true` nécessite le bac à sable et empêche les utilisateurs de le désactiver.\n* `allowBypass`: `false` empêche le modèle de demander qu’une commande individuelle s’exécute en dehors du bac à sable.\n* `addCurrentWorkingDirectory`: `false` empêche Copilot CLI d’ajouter automatiquement le répertoire de travail actuel aux chemins de lecture/écriture de la sandbox.\n* `sandboxMcpServers`: `true` nécessite que les serveurs MCP locaux démarrés par Copilot CLI s’exécutent dans le bac à sable. Les serveurs MCP distants ne s’exécutent pas dans le bac à sable local.\n* `sandboxLspServers`: `true` nécessite que les serveurs de langage démarrés par Copilot CLI s’exécutent dans le bac à sable.\n* `gitAuth`: `false` empêche Copilot CLI d’injecter un jeton GitHub pour les opérations Git HTTPS authentifiées dans le bac à sable.\n* `ghAuth`: `false` empêche Copilot CLI d’injecter un jeton GitHub pour GitHub CLI dans le sandbox.\n* `allowDevToolAccess`: `false` empêche l’accès automatique à la configuration des outils de développement, aux caches, aux registres et aux chaînes d’outils. Ces emplacements peuvent contenir des informations d’identification ou des jetons de registre de paquets. La désactivation de l’accès peut entraîner la restauration des packages, les opérations de Registre authentifiées ou les builds qui utilisent des caches partagés pour échouer, sauf si vous accordez explicitement les chemins requis.\n* `userPolicy`: objet qui configure les restrictions de ceinture de sécurité spécifiques au système de fichiers, au réseau et au macOS. Les propriétés prises en charge sont décrites dans les sections suivantes.\n\n### `sandbox.userPolicy.filesystem`\n\nConfigure l’accès au système de fichiers pour les processus en bac à sable (sandbox). Les chemins doivent être absolus. Les listes d’autorisations gérées sont comparées aux listes configurées par l’utilisateur sur la base d’une correspondance exacte de la chaîne de chemin, et non selon la couverture d’un chemin parent ou enfant.\n\n* `readwritePaths` : tableau de chemins d’accès que les processus en bac à sable peuvent lire et écrire. Un chemin configuré par l’utilisateur reste disponible uniquement si sa chaîne exacte apparaît également dans chaque source managée qui spécifie cette propriété. Un tableau managé vide supprime tous les octrois de chemins d’accès en lecture/écriture configurés par l’utilisateur, mais ne supprime pas l’accès assemblé séparément, comme les répertoires temporaires ou le répertoire de travail actif.\n* `readonlyPaths`: Un tableau de chemins d’accès que les processus en bac à sable peuvent lire, mais dans lesquels ils ne peuvent pas écrire. Un chemin configuré par l’utilisateur reste disponible uniquement si sa chaîne exacte apparaît également dans chaque source managée qui spécifie cette propriété. Un tableau managé vide supprime tous les octrois de chemins en lecture seule configurés par l’utilisateur, mais ne supprime pas l’accès assemblé séparément.\n* `deniedPaths`: tableau de chemins auxquels les processus en bac à sable ne peuvent pas accéder. Une valeur managée ajoute, au lieu de remplacer, les chemins d’accès refusés d’un utilisateur.\n\n### `sandbox.userPolicy.network`\n\nConfigure l’accès réseau pour les processus en bac à sable (sandbox).\n\n* `allowOutbound`: `false` bloque l’accès réseau sortant.\n* `allowLocalNetwork`: `false` empêche l’accès au réseau local.\n\nLe comportement du réseau varie selon le système d’exploitation. En particulier, un proxy n’est pas une limite complète de contrôle de sortie, car certaines applications peuvent ignorer les paramètres de proxy.\n\n### `sandbox.userPolicy.seatbelt`\n\nConfigure les options de ceinture de sécurité spécifiques à macOS.\n\n* `keychainAccess`: `false` empêche les processus en bac à sable d’accéder au trousseau macOS."}