# Lancer des scripts avec execute

> tokenade execute lance un court script et ne renvoie que sa sortie standard, masquée et compactée : les données brutes restent hors du contexte.

Source: https://tokenade.net/fr/docs/execute · Updated: 2026-10-07

`tokenade execute` exécute un court script et ne vous rend que ce qu'il affiche. Servez-vous-en quand la réponse est une valeur dérivée (un compte, un filtre, une somme) et que les données d'origine coûteraient cher dans le contexte de votre agent. Alias : `exec`, `run-script`.

## Utilisation

```text
tokenade execute --lang <name> [--script CODE | -] [--cwd DIR] \
               [--timeout SECS] [--cap BYTES] [--no-compact] [--no-redact]
tokenade execute --list   # show supported interpreters
```

| Option | Défaut | Effet |
| --- | --- | --- |
| `--lang <name>` | obligatoire | `bash`, `sh`, `python`, `node`, `ruby`, `awk`, `jq`, `perl` |
| `--script CODE` | | Code à exécuter. `--script -` lit le script sur l'entrée standard |
| `--script-file F` | | Lit le script depuis un fichier, sans échappement shell à gérer |
| `--cwd DIR` | répertoire courant | Répertoire de travail |
| `--timeout SECS` | `30` (max `600`) | Tue le script après ce nombre de secondes |
| `--cap BYTES` | 1 Mio (max 16 Mio) | Plafond de la sortie standard |
| `--no-compact` | désactivé | Saute le compacteur appliqué après exécution |
| `--no-redact` | désactivé | Saute le masquage des secrets (déconseillé) |
| `--sandbox` | désactivé | Exécute sous bubblewrap (`bwrap`) : tout le système de fichiers en lecture seule, un `/tmp` neuf en écriture, pas de réseau. Aussi `TOKENADE_EXEC_SANDBOX=1` |
| `--sandbox-net` | désactivé | Autorise le réseau dans le bac à sable. Aussi `TOKENADE_EXEC_SANDBOX_NET=1` |
| `--list` | | Affiche les interpréteurs pris en charge et quitte |
| `--json` | | Avec `--list`, affiche les interpréteurs en JSON |

## Ce que « sandbox » veut dire ici

Par défaut, le script tourne dans un processus séparé avec un environnement nettoyé, un délai maximal et des plafonds de sortie. Ce n'est pas une prison au niveau des appels système : il s'exécute sous votre identité, avec votre système de fichiers et votre réseau. Traitez un script lancé ici exactement comme si vous le lanciez dans votre propre shell.

`--sandbox` ajoute un vrai confinement sous Linux grâce à bubblewrap. Si `bwrap` n'est pas installé, `execute` refuse de s'exécuter plutôt que de tourner sans confinement.

## Exemples

```text
$ tokenade execute --list
Available interpreters:
  bash     (binary: bash)
  sh       (binary: sh)
  python   (binary: python3)
  node     (binary: node)
  ruby     (binary: ruby)
  awk      (binary: awk)
  jq       (binary: jq)
  perl     (binary: perl)
```

```text
$ tokenade execute --lang python --script 'print(sum(range(101)))'
5050
```

Les données envoyées par un pipe arrivent sur l'entrée standard du script ; une grosse sortie est donc réduite là où elle est produite :

```text
$ cat orders.json | tokenade execute --lang python \
    --script 'import json,sys; print(len(json.load(sys.stdin)["items"]))'
2
```

Un script long ou plein de guillemets est plus simple depuis un fichier :

```bash
tokenade execute --lang python --script-file ./count_errors.py < build.log
```

## Codes de sortie

| Code | Signification |
| --- | --- |
| Code du script | `execute` renvoie le code de sortie du script (`sys.exit(3)` donne `3`) |
| `255` | Délai dépassé. La sortie produite avant l'arrêt est conservée |
| `127` | `--lang` inconnu |

En cas de délai dépassé, le message indique comment l'augmenter :

```text
tokenade execute: timed out after 1.01s (ceiling 1s). Raise it with `--timeout <secs>` (max 600), or narrow the script. …
```

## Pièges

- **jq tourne avec `-n`.** Lisez les données reçues explicitement avec `input` : `--script 'input | .items | length'`. Un simple `.items | length` ne voit aucune entrée et affiche `0`.
- `--script -` utilise l'entrée standard pour le script lui-même : vous ne pouvez donc pas y envoyer de données en plus. Même chose pour un script `bash` ou `sh` de plus de 64 Kio. Utilisez plutôt `--script-file`.
- Par défaut, la sortie est masquée (secrets), puis compactée et plafonnée. Si le résultat semble tronqué, augmentez `--cap` ou réduisez ce que le script affiche.
- Gardez des scripts courts. `execute` sert aux calculs jetables ; un code que vous allez modifier et relancer a sa place dans un vrai fichier.

## Voir aussi

- [wrap, raw et filter](https://tokenade.net/fr/docs/wrap-raw-filter)
- [Compaction des sorties et stash](https://tokenade.net/fr/docs/compaction)
- [Récupérer une sortie repliée](https://tokenade.net/fr/docs/expand-ref-disclose)
