> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Exécuter Muse Code dans une sandbox

> Exécutez la CLI Muse Code sur un dépôt dans une sandbox, récupérez le résultat et arrêtez les ressources de calcul.

Exécutez Muse Code dans une sandbox CoreWeave pour modifier des fichiers et lancer des commandes dans un Workspace distant. Ce guide utilise le kit de développement logiciel (SDK) Sandboxes pour installer l’interface en ligne de commande (CLI) et cloner un dépôt. Vous exécutez ensuite une tâche sans terminal interactif, puis récupérez le résultat avant d’arrêter la sandbox. Le processus de l’agent et le Workspace s’exécutent sur CoreWeave, tandis que les requêtes adressées au modèle sont envoyées à Meta.

<h2 id="prerequisites">
  Prérequis
</h2>

Avant de commencer, vous devez disposer des éléments suivants :

* Un [jeton d’accès à l’API CoreWeave](/fr/products/sandboxes/placement#choose-and-get-credentials) avec l’action `SANDBOX_USER`.
* Une [clé API Meta](https://dev.meta.ai/docs/muse-code/auth) donnant accès à Muse Code.
* L’URL d’un dépôt public que la sandbox peut cloner. Pour les dépôts privés, des identifiants d’authentification Git doivent être disponibles dans la sandbox.
* Python 3.11 ou version ultérieure avec `uv`, ou Node.js 22 ou version ultérieure avec `npm`.

Chargez vos identifiants d’authentification depuis votre gestionnaire de secrets dans l’environnement de votre terminal local. Remplacez `[API-ACCESS-TOKEN]` par votre jeton d’accès à l’API CoreWeave et `[META-API-KEY]` par votre clé API Meta :

```bash theme={"system"}
export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"
export META_API_KEY="[META-API-KEY]"
```

Le script transmet la clé Meta via l’entrée standard afin qu’elle n’apparaisse ni dans les arguments de la commande ni dans la configuration du bac à sable. Pour un identifiant d’authentification partagé par l’équipe et injecté en tant que variable d’environnement lors de la création du sandbox, consultez [Secrets Forge](/fr/products/sandboxes/secrets).

<h2 id="install-the-sandbox-client">
  Installer le client Sandboxes
</h2>

Choisissez un langage et préparez un projet local :

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    mkdir muse-sandbox
    cd muse-sandbox
    uv init --bare --python 3.11
    uv venv --python 3.11
    source .venv/bin/activate
    uv pip install 'cwsandbox>=1.14.2'
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    mkdir muse-sandbox
    cd muse-sandbox
    npm init -y
    npm install @coreweave/cwsandbox@0.5.0-beta.0 tsx
    ```
  </Tab>
</Tabs>

<h2 id="run-a-task-in-the-sandbox">
  Exécuter une tâche dans la sandbox
</h2>

Enregistrez le script correspondant à votre langage sous le nom de fichier indiqué. Chaque script crée une sandbox sans serveur dotée d’une durée de vie maximale de 30 minutes et effectue les étapes suivantes :

1. Installe Muse Code à l’aide du programme d’installation de Meta.
2. Clone votre dépôt dans le répertoire `/workspace/project`.
3. Exécute `muse exec` pour compiler et tester une CLI de sparkline qui affiche des nombres sous forme de petit graphique.
4. Exécute indépendamment la CLI générée, vérifie sa sortie et enregistre le fichier `sparkline.mjs` en local.
5. Arrête la sandbox dans un bloc `finally`, y compris en cas d’échec de la configuration ou de l’exécution.

Ces exemples ont été testés avec Muse Code 1.3.0. Le programme d’installation pouvant installer une version plus récente, chaque script exécute `muse --version` après l’installation.

L’exemple utilise `--yolo` pour désactiver les demandes d’approbation de Muse Code ainsi que la sandbox du système d’exploitation (OS), et pour accorder sa confiance au Workspace le temps de cette exécution. CoreWeave fournit la sandbox externe. Muse peut accéder aux fichiers, aux identifiants d’authentification et aux destinations réseau disponibles dans cette sandbox. Utilisez un dépôt de confiance et ne fournissez que les identifiants d’authentification nécessaires à la tâche. Pour plus d’informations, consultez [Autorisations de Muse Code](https://dev.meta.ai/docs/muse-code/permissions).

<Tabs>
  <Tab title="Python">
    ```python title="run_muse.py" theme={"system"}
    import os
    import sys
    from pathlib import Path

    from cwsandbox import Sandbox

    if len(sys.argv) != 2:
        raise SystemExit("Usage: python run_muse.py [REPOSITORY-URL]")
    meta_api_key = os.environ["META_API_KEY"]

    sandbox = Sandbox.run(
        container_image="node:22-bookworm",
        resources={"cpu": "2", "memory": "4Gi"},
        max_lifetime_seconds=1800,
        tags=["muse-code"],
    )
    try:
        sandbox.wait()
        commands = [
            ["bash", "-o", "pipefail", "-ec", "curl -fsSL https://dev.meta.ai/install.sh | bash"],
            ["bash", "-ec", '"$HOME/.local/bin/muse" --version'],
            ["git", "clone", "--", sys.argv[1], "/workspace/project"],
        ]
        for command in commands:
            result = sandbox.exec(command, timeout_seconds=600, check=True).result()
            print(result.stdout, end="")

        agent = sandbox.exec(
            [
                "bash", "-ec",
                'IFS= read -r META_API_KEY; export META_API_KEY; '
                'exec "$HOME/.local/bin/muse" exec --yolo "$1"',
                "bash",
                "Create sparkline.mjs, a dependency-free Node.js CLI that converts its "
                "numeric arguments to a sparkline using ▁▂▃▄▅▆▇█. Scale from the minimum "
                "to the maximum and round to the nearest bar index. "
                "Running node sparkline.mjs 2 4 8 4 2 must print ▁▃█▃▁ followed by "
                "a newline. Run that command to test it.",
            ],
            cwd="/workspace/project",
            stdin=True,
            timeout_seconds=600,
        )
        # Laisser stdin ouvert jusqu’à ce que Muse ait terminé, pour éviter d’interrompre une requête qui ne produit aucune sortie.
        agent.stdin.writeline(meta_api_key).result()
        result = agent.result()
        print(result.stdout, end="")
        print(result.stderr, end="", file=sys.stderr)
        if result.returncode != 0:
            raise SystemExit(result.returncode)

        chart = sandbox.exec(
            ["node", "sparkline.mjs", "2", "4", "8", "4", "2"],
            cwd="/workspace/project", check=True,
        ).result()
        if chart.stdout != "▁▃█▃▁\n":
            raise RuntimeError(f"Unexpected sparkline: {chart.stdout!r}")
        print(chart.stdout, end="")
        source = sandbox.exec(
            ["cat", "/workspace/project/sparkline.mjs"], check=True
        ).result()
        Path("sparkline.mjs").write_text(source.stdout, encoding="utf-8")
    finally:
        sandbox.stop().result()
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript title="run_muse.mts" theme={"system"}
    import { writeFile } from "node:fs/promises";
    import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

    const repository = process.argv[2];
    if (!repository) throw new Error("Pass a repository URL.");
    const metaApiKey = process.env.META_API_KEY;
    if (!metaApiKey) throw new Error("Set META_API_KEY.");

    const client = createSandboxClientFromEnv();
    const sandbox = await client.create({
      containerImage: "node:22-bookworm",
      resources: { cpu: "2", memory: "4Gi" },
      maxLifetimeSeconds: 1800,
      waitUntilRunning: false,
      tags: ["muse-code"],
    });
    try {
      await sandbox.wait();
      const commands = [
        ["bash", "-o", "pipefail", "-ec", "curl -fsSL https://dev.meta.ai/install.sh | bash"],
        ["bash", "-ec", '"$HOME/.local/bin/muse" --version'],
        ["git", "clone", "--", repository, "/workspace/project"],
      ];
      for (const command of commands) {
        const result = await sandbox.commands.run(command, { timeoutMs: 600_000, check: true });
        process.stdout.write(result.stdout);
      }

      const agent = await sandbox.commands.start(
        [
          "bash", "-ec",
          'IFS= read -r META_API_KEY; export META_API_KEY; ' +
            'exec "$HOME/.local/bin/muse" exec --yolo "$1"',
          "bash",
          "Create sparkline.mjs, a dependency-free Node.js CLI that converts its " +
            "numeric arguments to a sparkline using ▁▂▃▄▅▆▇█. Scale from the minimum " +
            "to the maximum and round to the nearest bar index. " +
            "Running node sparkline.mjs 2 4 8 4 2 must print ▁▃█▃▁ followed by " +
            "a newline. Run that command to test it.",
        ],
        {
          cwd: "/workspace/project",
          stdin: true,
          timeoutMs: 600_000,
        },
      );
      // Garder stdin ouvert jusqu’à ce que Muse ait terminé, pour ne pas interrompre une requête silencieuse.
      await agent.stdin.write(metaApiKey + "\n");
      const result = await agent.wait();
      process.stdout.write(result.stdout);
      process.stderr.write(result.stderr);
      if (!result.ok) throw new Error(`Muse Code exited with code ${result.exitCode}.`);

      const chart = await sandbox.commands.run(
        ["node", "sparkline.mjs", "2", "4", "8", "4", "2"],
        { cwd: "/workspace/project", check: true },
      );
      if (chart.stdout !== "▁▃█▃▁\n") {
        throw new Error(`Unexpected sparkline: ${JSON.stringify(chart.stdout)}`);
      }
      process.stdout.write(chart.stdout);
      const source = await sandbox.commands.run(
        ["cat", "/workspace/project/sparkline.mjs"], { check: true },
      );
      await writeFile("sparkline.mjs", source.stdout, "utf8");
    } finally {
      await sandbox.stop();
    }
    ```
  </Tab>
</Tabs>

Dans le répertoire de votre projet local, remplacez `[REPOSITORY-URL]` par l’URL de votre dépôt public, puis exécutez le script :

<Tabs>
  <Tab title="Python">
    ```bash theme={"system"}
    python run_muse.py [REPOSITORY-URL]
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash theme={"system"}
    npx tsx run_muse.mts [REPOSITORY-URL]
    ```
  </Tab>
</Tabs>

Une fois l’installation terminée et la sortie de l’agent affichée, le script vérifie puis affiche la sparkline :

```text theme={"system"}
▁▃█▃▁
```

Le script enregistre le fichier `sparkline.mjs` généré dans le répertoire local de votre projet, puis arrête le sandbox. Si le fichier existe déjà localement, le script l'écrase. La vérification de la sortie s'exécute indépendamment du test propre à Muse et porte sur l'entrée de cet exemple. Pour une tâche plus conséquente, remplacez-la par des tests adaptés à vos exigences.

Ces exemples ne configurent pas de stockage persistant. Copiez les fichiers dont vous avez besoin hors du sandbox avant l'exécution du bloc `finally`. Voir [opérations sur les fichiers](/fr/products/sandboxes/client/guides/file-operations) et [instantanés du système de fichiers](/fr/products/sandboxes/file-system-snapshots).

<h2 id="troubleshoot">
  Dépannage
</h2>

Effectuez les vérifications suivantes pour résoudre les problèmes courants :

* Si la création du sandbox échoue, vérifiez votre jeton d’accès à l’API CoreWeave et vos paramètres d’authentification.
* Si Muse Code signale une erreur d’authentification, vérifiez `META_API_KEY` et la configuration de votre compte Meta. L’identifiant d’authentification du sandbox ne sert pas à authentifier les requêtes envoyées au modèle.
* Si l’installation, le clonage ou les requêtes envoyées au modèle échouent, vérifiez l’accès sortant vers Meta et vers votre hébergeur Git. Ces exemples utilisent le placement sans serveur. Pour utiliser votre propre cluster CoreWeave Kubernetes Service (CKS), appliquez les paramètres client décrits dans [Configurer le placement et la politique CKS](/fr/products/sandboxes/agents#configure-cks-placement-and-policy). Vérifiez que la politique de l’exécuteur autorise le trafic sortant vers ces destinations.
* Si une tâche plus lourde dépasse le délai d’expiration, augmentez le délai d’expiration de la commande et la durée de vie du bac à sable avant de l’exécuter. La durée de vie de 30 minutes comprend le démarrage et l’installation. Voir [délais d’expiration des commandes](/fr/products/sandboxes/client/guides/execution#set-a-timeout) et [cycle de vie du sandbox](/fr/products/sandboxes/client/guides/sandbox-lifecycle).

<h2 id="next-steps">
  Étapes suivantes
</h2>

Pour plus d'informations, consultez les guides suivants :

* [Shells interactifs et TTY](/fr/products/sandboxes/client/guides/interactive-shells) explique comment accéder au terminal pour les agents interactifs.
* [Exécuter des agents dans des sandboxes CoreWeave](/fr/products/sandboxes/agents) compare les intégrations d’agents et les options de Workspace.
* [Le cookbook d’exécution en sandbox de Meta](https://dev.meta.ai/docs/cookbook/sandboxed-execution) présente un flux de travail en trois temps (reproduire, corriger, vérifier) reposant sur une boucle d’outils personnalisée dans Docker.
* [La documentation de Muse Code](https://dev.meta.ai/docs/muse-code) traite de la configuration de l’agent et d’autres flux de travail en CLI.