Sandbox de la CLI de Code Cortex¶

La CLI de Code Cortex peut exécuter des commandes shell dans un environnement sandbox pour restreindre l’accès au système de fichiers, l’accès au réseau et les capacités de traitement. L’exécution en sandbox ajoute une couche d’isolation, de sorte que l’agent ne puisse pas modifier accidentellement des fichiers ou accéder à des ressources en dehors de votre projet.

Important

La prise en charge de cette fonctionnalité est expérimentale et peut être soumise à modifications.

Prise en charge de plateforme¶

Le sandbox utilise les fonctions d’isolation intégrées du système d’exploitation pour restreindre les commandes.


Plateforme	Mise en œuvre	Dépendances
macOS	`sandbox-exec` (intégré)	`ripgrep`
Linux	`bubblewrap`	`bubblewrap`, `socat` et `ripgrep`
Windows	Jetons restreints natifs	Aucun(e)

Installation des dépendances¶

macOS :

brew install ripgrep

Debian/Ubuntu :

sudo apt-get install bubblewrap socat ripgrep

Fedora / RHEL :

sudo dnf install bubblewrap socat ripgrep

Activation du sandbox¶

Utilise la commande barre oblique /sandbox dans la CLI de Cortex Code :

/sandbox                          # Interactive selector
/sandbox runtime on               # Enable sandbox
/sandbox runtime off              # Disable sandbox
/sandbox runtime status           # Show sandbox status
/sandbox status                   # Show current sandbox status

Vous pouvez également activer le sandbox dans votre fichier de paramètres. Ajoutez un objet sandbox à ~/.snowflake/cortex/settings.json (au niveau de l’utilisateur) ou``.snowflake/cortex/settings.json`` (au niveau du projet) :

{
  "sandbox": {
    "enabled": true
  }
}

Le mode d’autorisation par défaut est "regular". Pour utiliser le mode d’autorisation automatique, définissez`` »mode »: « autoAllow »`` explicitement. Voir Modes d’autorisation.

Modes d’autorisation¶

Le sandbox dispose de deux modes d’autorisation qui contrôlent la manière dont les commandes sont approuvées :


Mode	Définition de la valeur	Comportement
Autorisation automatique	`"autoAllow"`	Les commandes qui peuvent être exécutées en sandbox s’exécutent automatiquement sans invite. Les commandes qui ne peuvent pas être exécutées en sandbox (par exemple, celles nécessitant un accès réseau à des domaines non autorisés) reviennent au flux d’autorisation normal.
Standard	`"regular"`	Toutes les commandes demandent une approbation, même lorsqu’elles sont exécutées dans le sandbox.

Réglez le mode avec la commande /sandbox ou dans les paramètres :

/sandbox mode auto                # Set auto-allow mode
/sandbox mode regular             # Set regular mode

Restrictions du système de fichiers¶

Le sandbox contrôle les chemins que les commandes peuvent lire et écrire.

Comportement par défaut¶

Répertoire de travail : Toujours autorisé pour la lecture et l’écriture.
Répertoire des connaissances (~/.snowflake/cortex/skills ) : autorisé.
Répertoire contextuel (~/.snowflake/cortex/.ctx ) : autorisé lorsque ctxAvailable est activé.

Chemins protégés (toujours refusés en écriture)¶

Les chemins suivants sont toujours protégés, quelle que soit votre configuration :

Fichiers de configuration shell : ~/.bashrc ~/.bash_profile, ~/.zshrc, ~/.zprofile, ~/.profile, ~/.bash_login et ~/.bash_logout.
Hooks Git : ~/.git/hooks, .git/hooks
Configuration SSH : ~/.ssh/authorized_keys, ~/.ssh/config
Répertoires et fichiers de paramètres gérés :/Library/Application Support/Cortex/ (macOS ), /etc/cortex/ (Linux),``%ProgramData%Cortex`` (Windows)

Règles du système de fichiers personnalisé¶

Configurez l’accès au système de fichiers dans les paramètres :

{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "allowRead": [],
      "denyRead": ["/private/secrets"],
      "allowWrite": ["/tmp", "~/projects"],
      "denyWrite": ["/etc", "/var"]
    }
  }
}


Réglage	Par défaut	Description
`allowRead`	`[]` (autoriser tout)	Chemins que le sandbox peut lire. Un tableau vide signifie que tous les chemins sont autorisés (sauf ceux dans `denyRead`).
`denyRead`	`[]`	Chemins que le sandbox ne peut pas lire. A priorité sur `allowRead`.
`allowWrite`	`[]` (répertoire de travail uniquement)	Chemins dans lesquels le sandbox peut écrire.
`denyWrite`	`[]`	Chemins dans lesquels le sandbox ne peut pas écrire. A priorité sur `allowWrite`.

Important

Les règles de refus ont toujours la priorité sur les règles d’autorisation. Si un chemin correspond à allowWrite et``denyWrite``, le chemin est refusé.

Restrictions réseau¶

Le sandbox peut restreindre les domaines auxquels les commandes peuvent accéder sur le réseau.

{
  "sandbox": {
    "enabled": true,
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
      "deniedDomains": ["*.internal.company.com"],
      "allowLocalBinding": false
    }
  }
}


Réglage	Par défaut	Description
`allowedDomains`	`[]` (autoriser tout)	Domaines auxquels le sandbox peut accéder. Un tableau vide signifie que tous les domaines sont autorisés (sauf ceux de la section `deniedDomains`). Prend en charge les caractères génériques (`*.example.com`).
`deniedDomains`	`[]`	Domaines auxquels le sandbox ne peut pas accéder. A priorité sur `allowedDomains`. Prend en charge les caractères génériques.
`allowLocalBinding`	`false`	Si les commandes exécutées en sandbox peuvent être liées à des ports locaux.

Repli pour les commandes hors sandbox¶

Certaines commandes peuvent ne pas être compatibles avec le sandbox. Le paramètre allowUnsandboxedCommands contrôle ce qui se passe lorsqu’une commande ne peut pas s’exécuter à l’intérieur du sandbox.


Réglage	Comportement
`true` (par défaut)	L’agent peut demander l’exécution de la commande sur l’hôte. Vous êtes invité à approuver.
`false`	Les commandes doivent être exécutées dans le sandbox ou être listées dans `excludedCommands`. Si ni l’un ni l’autre ne s’applique, la commande échoue.

Commandes exclues¶

Vous pouvez spécifier des commandes qui doivent toujours s’exécuter sur l’hôte, en dehors du sandbox :

{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": true,
    "excludedCommands": ["docker", "kubectl"]
  }
}

Les commandes exclues contournent le sandbox et suivent le flux d’autorisation normal.

Référence des paramètres¶

L’objet de paramètres sandbox complet :

{
  "sandbox": {
    "enabled": false,
    "mode": "regular",
    "allowUnsandboxedCommands": true,
    "excludedCommands": [],
    "permissions": {
      "allow": [],
      "deny": []
    },
    "network": {
      "allowedDomains": [],
      "deniedDomains": [],
      "allowLocalBinding": false
    },
    "filesystem": {
      "allowRead": [],
      "denyRead": [],
      "allowWrite": [],
      "denyWrite": []
    },
    "ctxAvailable": true
  }
}


Réglage	Par défaut	Description
`enabled`	`false`	Activer ou désactiver le sandbox.
`mode`	`"regular"`	Mode d’autorisation : `"regular"` ou `"autoAllow"`.
`allowUnsandboxedCommands`	`true`	Autorisez le retour à l’exécution de l’hôte lorsqu’une commande ne peut pas être mise en sandbox.
`excludedCommands`	`[]`	Commandes qui s’exécutent toujours sur l’hôte, en dehors du sandbox.
`permissions.allow`	`[]`	Règles d’autorisation de haut niveau. Prend en charge des modèles tels que `WebFetch(domain:example.com)`, `Edit(path)`, `Read(path)`, `Bash(command)`.
`permissions.deny`	`[]`	Règles d’interdiction de haut niveau. Même syntaxe de modèle que `permissions.allow`. A la priorité sur les règles d’autorisation.
`network.allowedDomains`	`[]`	Liste d’autorisation de domaine réseau (vide = tout autoriser). Prend en charge les caractères génériques.
`network.deniedDomains`	`[]`	Liste d’interdiction du domaine du réseau. A la priorité sur la liste d’autorisation.
`network.allowLocalBinding`	`false`	Autoriser les commandes exécutées en sandbox à se lier à des ports locaux.
`filesystem.allowRead`	`[]`	Liste d’autorisation de lecture (vide = autoriser tout sauf refuser).
`filesystem.denyRead`	`[]`	Lire la liste d’interdiction. A priorité.
`filesystem.allowWrite`	`[]`	Écrire une liste d’autorisation.
`filesystem.denyWrite`	`[]`	Écrire une liste d’interdiction. A priorité.
`ctxAvailable`	`true`	Autoriser l’accès des sandbox au répertoire de contexte (`~/.snowflake/cortex/.ctx`), utilisés pour stocker le contexte de la conversation et les données de la session.

Périmètres de configuration¶

Les paramètres sandbox suivent la même priorité que les autres paramètres de Cortex Code :

Niveau projet (priorité la plus élevée) : .snowflake/cortex/settings.json
Niveau utilisateur : ~/.snowflake/cortex/settings.json
Géré/Exécuté : Les administrateurs peuvent appliquer des politiques de sandbox via le fichier de paramètres géré. Voir Paramètres gérés (politique de l’organisation).