> ## 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 Codex dans une sandbox
> Exécutez Codex CLI dans une sandbox, connectez une CLI locale ou utilisez les applications de bureau et mobiles avec un projet distant.
Exécutez Codex sur un dépôt dans une sandbox CoreWeave. Vous pouvez exécuter l’interface
en ligne de commande (CLI) de Codex dans la sandbox, connecter votre CLI locale au serveur d’application
Codex ou utiliser les applications de bureau et mobiles avec un projet distant. Dans les trois
cas, le processus de l’agent, le Workspace et l’exécution des commandes restent dans la sandbox.
Ces exemples utilisent OpenAI pour les requêtes au modèle.
Choisir comment exécuter Codex dans une sandbox
Le serveur d’application est le backend de l’agent pour les connexions distantes de la CLI et de l’application de bureau.
Choisissez où vous souhaitez interagir avec l’agent :
| Interface | Où s’exécute l’interface | Où s’exécute le processus de l’agent | Connexion |
| - | - | - | - |
| [Exécuter Codex CLI dans une sandbox](#run-codex-cli-in-a-sandbox) | Dans la sandbox, affichée dans votre terminal | Dans la sandbox | Rattachement avec `cws-agent` |
| [Connecter votre CLI locale au serveur d’application Codex](#connect-your-local-cli-to-codex-app-server) | Sur votre ordinateur | Dans la sandbox, via le serveur d’application Codex | Connexion avec `codex --remote` |
| [Utiliser les applications de bureau et mobile](#use-the-desktop-and-mobile-apps) | Sur votre ordinateur, ou sur un téléphone associé à cet ordinateur | Dans la sandbox, via le serveur d’application Codex | Ajoutez un projet Secure Shell (SSH) dans l’application de bureau. Associez votre téléphone via Remote. |
La CLI rattachée utilise `cws-agent` pour créer une sandbox. La CLI locale et l’application de bureau
partagent la même [configuration de sandbox SSH](#create-an-ssh-accessible-sandbox).
Pour l’accès mobile, associez votre téléphone à l’ordinateur hôte via Remote. Le
téléphone se connecte à cet hôte, qui se connecte lui-même à la sandbox via SSH. L’ordinateur
hôte doit rester allumé, en ligne et exécuter l’application. Voir
[Mobile et autre ordinateur de bureau via Remote](#mobile-and-another-desktop-through-remote).
L’interface utilisateur en mode terminal (TUI) locale envoie les entrées, affiche les sorties et gère
les approbations. C’est le serveur d’application qui détient la session d’agent distante : il ne se contente pas de relayer
des commandes individuelles provenant d’un agent exécuté sur votre ordinateur portable. Voir le
[guide du serveur d’application OpenAI](https://learn.chatgpt.com/docs/app-server).
Le démarrage du serveur d’application n’enregistre pas ses sessions auprès de l’application de bureau ou mobile.
Ces interfaces s’appuient sur une configuration de connexion distincte, décrite dans
[Utiliser les applications de bureau et mobile](#use-the-desktop-and-mobile-apps). La documentation
Remote d’OpenAI ne prévoit pas de rattachement depuis un site web pour cette
session auto-hébergée. L’accès via un navigateur sort du cadre de ce guide.
Le flux de travail programmatique de l’API Agents repose sur un modèle d’exécution distinct. Voir la
[recette OpenAI Agents API](https://github.com/coreweave/cwsandbox-recipes/tree/main/recipes/openai-agents-api).
Prérequis
Avant de commencer, assurez-vous de disposer des éléments suivants :
* Un [jeton d’accès à l’API CoreWeave](/fr/products/sandboxes/placement#choose-and-get-credentials) disposant de l’action `SANDBOX_USER`. Vous devez également disposer de capacité pour une sandbox CPU.
* Un compte OpenAI pris en charge par Codex, ou une clé API OpenAI. L’exemple de serveur
d’application de ce guide utilise l’authentification par clé API et la facturation à l’usage de l’API.
* L’URL d’un dépôt public. Le clonage de dépôts privés nécessite des identifiants d’authentification Git dans la sandbox.
* Une connectivité sortante vers OpenAI, les registres de paquets et votre hébergeur Git
Dans votre terminal local, remplacez `[API-ACCESS-TOKEN]` par votre jeton d’accès à l’API CoreWeave, puis chargez
l’identifiant d’authentification de la sandbox :
```bash theme={"system"}
export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"
```
Les exemples de création de sandbox définissent une durée de vie maximale de 8 heures en temps réel, et non un délai
d’inactivité. Arrêtez la sandbox une fois votre travail terminé. L’utilisation des modèles
et les ressources de calcul de la sandbox peuvent être facturées séparément.
Exécuter Codex CLI dans une sandbox
Utilisez `cws-agent` pour lancer une sandbox et y rattacher votre terminal. La TUI de Codex
et le processus de l’agent s’exécutent tous deux dans la sandbox.
1. Suivez les [instructions d’installation de `cws-agent`](https://github.com/coreweave/cws-agent#install).
Pour une authentification par clé d’API, exportez `OPENAI_API_KEY` localement avant le lancement.
L’outil la transmet à la sandbox et l’enregistre via la commande de connexion de Codex.
2. Remplacez `[SANDBOX-NAME]` par un nom de 1 à 40 caractères composé de lettres minuscules,
de chiffres ou de traits d’union, et commençant par une lettre ou un chiffre. Remplacez `[REPOSITORY-URL]`
par l’URL de votre dépôt public :
```bash theme={"system"}
cws-agent launch [SANDBOX-NAME] --agent codex --repo-url [REPOSITORY-URL] --lifetime 8h --permission-mode native
```
Si une invite vous propose d’importer des skills ou des serveurs Model Context Protocol (MCP), appuyez sur
**Enter** pour l’ignorer dans le cadre de cet exemple. Codex s’ouvre dans le répertoire du projet de la sandbox. Suivez ses invites
relatives à la confiance accordée au Workspace et à l’authentification.
`--permission-mode native` conserve les paramètres d’autorisation propres à Codex. À défaut, l’encapsuleur
ignore par défaut les invites d’approbation. Consultez
[Modes d’autorisation de `cws-agent`](https://github.com/coreweave/cws-agent/blob/main/docs/permissions.md).
3. Si vous devez vous connecter à un compte, quittez la TUI, puis authentifiez-vous dans la sandbox :
```bash theme={"system"}
cws-agent login [SANDBOX-NAME]
cws-agent connect [SANDBOX-NAME] --permission-mode native
```
Suivez la procédure de connexion affichée par Codex. Pour la connexion par appareil en mode sans interface graphique et les restrictions
liées au Workspace, consultez [Authentification Codex](https://learn.chatgpt.com/docs/auth).
4. Effectuez l’étape [Vérifier la session](#check-the-session). Pour vous reconnecter ultérieurement tant que la
sandbox est en cours d’exécution, utilisez la même commande `connect`. Pour reprendre une conversation Codex
enregistrée, consultez [Sessions `cws-agent`](https://github.com/coreweave/cws-agent/blob/main/docs/sessions.md).
Créer une sandbox accessible par SSH
Effectuez cette configuration pour la CLI locale ou pour l’application de bureau. Elle utilise le
kit de développement logiciel (SDK) Sandboxes pour créer une sandbox dans laquelle Codex est installé
et authentifié pour un utilisateur SSH non root. Elle ne nécessite pas `cws-agent`.
Cette configuration s’appuie sur un [point de terminaison en mode passthrough TLS (Transport Layer Security)](/fr/products/sandboxes/public-endpoints)
et sur `stunnel` pour faire transiter SSH par le point de terminaison. Une `ProxyCommand`
Python générée vérifie le certificat TLS, puis SSH
authentifie votre clé et vérifie la clé d’hôte. Le serveur d’application n’expose aucun écouteur
public. Cette approche est conforme aux [recommandations d’OpenAI en matière d’exposition réseau](https://learn.chatgpt.com/docs/remote-connections#authentication-and-network-exposure).
Préparer le client SSH
Utilisez un ordinateur macOS ou Linux équipé de Python 3.12+, de `uv` et d’OpenSSH.
Pour l’accès depuis l’application de bureau, utilisez une application et un système d’exploitation pris en charge, conformément aux
[instructions relatives aux hôtes SSH](https://learn.chatgpt.com/docs/remote-connections#connect-to-an-ssh-host) d’OpenAI.
Cette configuration utilise l’identifiant d’authentification de la sandbox mentionné dans [Prérequis](#prerequisites), ainsi qu’une
clé API OpenAI associée à la facturation de l’API.
Remplacez `[OPENAI-API-KEY]` par votre clé API OpenAI :
```bash theme={"system"}
uv venv --python 3.12
source .venv/bin/activate
uv pip install 'cwsandbox==1.14.2'
export OPENAI_API_KEY="[OPENAI-API-KEY]"
```
La configuration SSH générée utilise le chemin absolu de cet interpréteur Python
pour exécuter le redirecteur TLS. Conservez l’installation Python et le répertoire de sortie
disponibles tant que vous utilisez la sandbox.
Créez une clé SSH dédiée, puis chargez-la dans votre agent SSH en cours d’exécution. Choisissez un
nom de fichier qui n’est pas déjà utilisé et saisissez une phrase secrète lorsque vous y êtes invité :
```bash theme={"system"}
ssh-keygen -t ed25519 -f ~/.ssh/cw-codex
ssh-add ~/.ssh/cw-codex
```
La clé privée reste sur votre ordinateur. Le script de configuration ne copie que la clé
publique dans la sandbox.
Créer la sandbox SSH
Enregistrez le code suivant dans le fichier `create_codex_ssh.py`. Ce script crée une sandbox d’une durée de 8 heures, installe
Codex `0.154.0` et configure un compte `agent` non root avec une authentification SSH
par clé publique. Il transmet la clé OpenAI à `codex login` via l’entrée standard (stdin)
et ne stocke pas la clé dans la configuration de création de la sandbox. Codex enregistre ses identifiants de connexion
dans la sandbox.
Le script crée également un certificat TLS valide 1 jour, puis récupère le certificat
public et la clé d’hôte SSH via le SDK Sandboxes authentifié. La configuration
client générée vérifie ces deux éléments. Conservez le répertoire de sortie pour pouvoir vous reconnecter.
```python title="create_codex_ssh.py" theme={"system"}
import os
from pathlib import Path
import shlex
import sys
from cwsandbox import Endpoint, Sandbox, Service
if len(sys.argv) != 4:
raise SystemExit(
"Usage: python create_codex_ssh.py REPOSITORY_URL SSH_KEY OUTPUT_DIR"
)
repository, identity_arg, directory_arg = sys.argv[1:]
identity = Path(identity_arg).expanduser().resolve()
if not identity.is_file():
raise SystemExit("SSH private key not found. Generate the key pair first.")
public_key = Path(str(identity) + ".pub").read_bytes()
api_key = os.environ["OPENAI_API_KEY"]
if not api_key:
raise SystemExit("Set OPENAI_API_KEY first.")
directory = Path(directory_arg).expanduser().resolve()
directory.mkdir(mode=0o700, parents=True, exist_ok=False)
sandbox = Sandbox.run(
container_image="node:22-bookworm",
resources={"cpu": "2", "memory": "4Gi"},
max_lifetime_seconds=8 * 3600,
services=[
Service(
port=8443,
name="ssh",
visibility="public",
endpoint=Endpoint(kind="tls_passthrough"),
)
],
)
def run(command):
result = sandbox.exec(command, timeout_seconds=900).result()
if result.returncode != 0:
details = (result.stdout + result.stderr).replace(api_key, "[REDACTED]")
raise RuntimeError(details[-3000:])
return result.stdout
try:
(directory / "sandbox-id").write_text(sandbox.sandbox_id + "\n")
print("Sandbox created; ID saved in", directory / "sandbox-id", flush=True)
sandbox.wait()
address = next(
item.address for item in sandbox.service_addresses if item.port == 8443
)
host, port = address.rsplit(":", 1)
run(
[
"bash",
"-c",
"""
set -eu
apt-get update -qq
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq openssh-server stunnel4 bubblewrap
npm install --global @openai/codex@0.154.0
useradd --create-home --shell /bin/bash agent
usermod --password '*' agent
install -d -m 700 -o agent -g agent /home/agent/.ssh
install -d -m 755 /run/sshd /workspace
mkdir -p /etc/codex-ssh
chmod 700 /etc/codex-ssh
""",
]
)
sandbox.write_file("/home/agent/.ssh/authorized_keys", public_key).result()
run(
[
"bash",
"-c",
"chmod 600 /home/agent/.ssh/authorized_keys; chown agent:agent /home/agent/.ssh/authorized_keys",
]
)
run(["git", "clone", "--", repository, "/workspace/project"])
run(["chown", "-R", "agent:agent", "/workspace/project"])
login = sandbox.exec(
["runuser", "-u", "agent", "--", "codex", "login", "--with-api-key"],
stdin=True,
timeout_seconds=60,
)
login.stdin.write((api_key + "\n").encode()).result()
login.stdin.close().result()
if login.result().returncode != 0:
raise RuntimeError("Codex authentication failed.")
run(
[
"openssl",
"req",
"-x509",
"-newkey",
"rsa:2048",
"-noenc",
"-keyout",
"/etc/codex-ssh/tls.key",
"-out",
"/etc/codex-ssh/tls.crt",
"-days",
"1",
"-subj",
"/CN=codex-sandbox",
"-addext",
f"subjectAltName=DNS:{host}",
]
)
sandbox.write_file(
"/etc/codex-ssh/sshd_config",
b"""Port 2222
ListenAddress 127.0.0.1
HostKey /etc/ssh/ssh_host_ed25519_key
AuthorizedKeysFile .ssh/authorized_keys
PubkeyAuthentication yes
PasswordAuthentication no
KbdInteractiveAuthentication no
PermitRootLogin no
AllowUsers agent
AllowTcpForwarding local
X11Forwarding no
Subsystem sftp internal-sftp
""",
).result()
sandbox.write_file(
"/etc/codex-ssh/stunnel.conf",
b"""pid = /run/codex-stunnel.pid
output = /var/log/codex-stunnel.log
[ssh]
accept = 0.0.0.0:8443
connect = 127.0.0.1:2222
cert = /etc/codex-ssh/tls.crt
key = /etc/codex-ssh/tls.key
""",
).result()
run(["chmod", "600", "/etc/codex-ssh/tls.key"])
run(
[
"/usr/sbin/sshd",
"-f",
"/etc/codex-ssh/sshd_config",
"-E",
"/var/log/codex-sshd.log",
]
)
run(["stunnel", "/etc/codex-ssh/stunnel.conf"])
certificate = directory / "tls.crt"
certificate.write_bytes(sandbox.read_file("/etc/codex-ssh/tls.crt").result())
host_key = (
sandbox.read_file("/etc/ssh/ssh_host_ed25519_key.pub").result().decode().strip()
)
known_hosts = directory / "known_hosts"
known_hosts.write_text("cw-codex " + host_key + "\n")
forwarder = directory / "tls_proxy.py"
forwarder.write_text('''"""Forward SSH through verified TLS, with backpressure in both directions."""
import asyncio
import ssl
import sys
async def main():
host, port, certificate = sys.argv[1:]
context = ssl.create_default_context(cafile=certificate)
remote_reader, remote_writer = await asyncio.open_connection(
host, int(port), ssl=context, server_hostname=host
)
local_reader = asyncio.StreamReader()
transport, _ = await asyncio.get_running_loop().connect_read_pipe(
lambda: asyncio.StreamReaderProtocol(local_reader), sys.stdin.buffer
)
async def upload():
while data := await local_reader.read(65536):
remote_writer.write(data)
await remote_writer.drain()
def write_output(data):
sys.stdout.buffer.write(data)
sys.stdout.buffer.flush()
async def download():
while data := await remote_reader.read(65536):
await asyncio.to_thread(write_output, data)
tasks = [asyncio.create_task(upload()), asyncio.create_task(download())]
try:
done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
for task in done:
task.result()
finally:
for task in tasks:
task.cancel()
transport.close()
remote_writer.close()
await remote_writer.wait_closed()
try:
asyncio.run(main())
except (OSError, ssl.SSLError) as error:
print(f'TLS proxy: {error}', file=sys.stderr)
sys.exit(1)
''')
proxy = shlex.join(
[sys.executable, str(forwarder), "%h", "%p", str(certificate)]
)
config = directory / "ssh_config"
config.write_text(f'''Host cw-codex
HostName {host}
Port {port}
User agent
IdentityFile "{identity}"
IdentitiesOnly yes
HostKeyAlias cw-codex
UserKnownHostsFile "{known_hosts}"
StrictHostKeyChecking yes
ServerAliveInterval 30
ProxyCommand {proxy}
''')
print("SSH config:", config, flush=True)
except BaseException as error:
try:
sandbox.stop().result()
except BaseException:
error.add_note(
f"Automatic cleanup failed. Stop sandbox {sandbox.sandbox_id} manually."
)
raise
```
Remplacez `[REPOSITORY-URL]` par l’URL d’un dépôt Git public, puis choisissez un nouveau
répertoire de sortie situé en dehors de votre dépôt :
```bash theme={"system"}
python create_codex_ssh.py [REPOSITORY-URL] ~/.ssh/cw-codex ~/.ssh/cw-codex-session
```
Si la configuration réussit, le script affiche l’emplacement du fichier `ssh_config` et laisse la
sandbox en cours d’exécution. Le répertoire de sortie contient également les fichiers `sandbox-id`, `tls.crt`
et `known_hosts`, ainsi que le redirecteur `tls_proxy.py`. Si la configuration échoue après la
création, le script tente d’arrêter la sandbox. Si l’arrêt échoue lui aussi, l’erreur
d’origine indique l’ID de la sandbox afin que vous puissiez la nettoyer manuellement.
Avant de connecter Codex, vérifiez la connexion SSH :
```bash theme={"system"}
ssh -F ~/.ssh/cw-codex-session/ssh_config cw-codex 'id -un; codex --version; test -d /workspace/project/.git && echo repository-ready'
```
La sortie doit contenir `agent`, `codex-cli 0.154.0` et `repository-ready`.
Si la première connexion échoue, réessayez une fois que le point de terminaison et les services ont fini
de démarrer. Si les connexions échouent toujours, examinez les fichiers `/var/log/codex-sshd.log` et
`/var/log/codex-stunnel.log` à l’aide du SDK Sandboxes.
Une fois la connexion SSH vérifiée, poursuivez avec
[votre CLI locale](#connect-your-local-cli-to-codex-app-server) ou avec les
[applications de bureau et mobiles](#use-the-desktop-and-mobile-apps).
Connecter votre CLI locale au serveur d’application Codex
Commencez par suivre les étapes de la section [Créer une sandbox accessible par SSH](#create-an-ssh-accessible-sandbox).
Utilisez une version LTS (support à long terme) de Node.js prise en charge pour installer localement la même
version de Codex. Le paquet npm requiert au minimum Node.js 16 :
```bash theme={"system"}
npm install --global @openai/codex@0.154.0
```
OpenAI considère le transport WebSocket du serveur d’application comme expérimental et non pris en charge pour
les charges de travail de production. Dans cet exemple, l’écouteur et le port redirigé sont liés à
des adresses de bouclage, et le trafic transite par SSH. Les autres processus de ces
hôtes peuvent accéder aux ports de bouclage. Utilisez des hôtes de confiance.
Connectez la CLI locale via un tunnel SSH :
1. Dans le répertoire du projet de la sandbox, démarrez le serveur d’application. Cette commande enregistre la sortie
de démarrage même si le serveur d’application s’arrête. Laissez le terminal ouvert :
```bash theme={"system"}
ssh -t -F ~/.ssh/cw-codex-session/ssh_config cw-codex 'cd /workspace/project && exec codex app-server --listen ws://127.0.0.1:4500 > /home/agent/codex-app-server.log 2>&1'
```
L’option `-t` alloue un terminal distant pour que **Ctrl+C** parvienne à l’écouteur.
2. Dans un deuxième terminal, redirigez un port local vers cet écouteur et laissez la
connexion ouverte :
```bash theme={"system"}
ssh -F ~/.ssh/cw-codex-session/ssh_config -N -o ExitOnForwardFailure=yes -L 127.0.0.1:4500:127.0.0.1:4500 cw-codex
```
3. Dans un troisième terminal, connectez la TUI locale et sélectionnez explicitement le répertoire
du projet distant :
```bash theme={"system"}
codex --remote ws://127.0.0.1:4500 --cd /workspace/project
```
4. Vérifiez que la TUI affiche `/workspace/project`, puis suivez les étapes de la section
[Vérifier la session](#check-the-session). Si la connexion échoue, examinez la
sortie de démarrage conservée :
```bash theme={"system"}
ssh -F ~/.ssh/cw-codex-session/ssh_config cw-codex 'cat /home/agent/codex-app-server.log'
```
Pour reprendre une conversation enregistrée pendant que l’écouteur est actif, rétablissez le tunnel
SSH, puis ouvrez le sélecteur de sessions distantes :
```bash theme={"system"}
codex resume --remote ws://127.0.0.1:4500 --cd /workspace/project
```
Sélectionnez la conversation à reprendre. Pour démarrer plutôt une nouvelle conversation, utilisez la
commande `codex --remote` d’origine.
Cet écouteur est distinct du serveur d’application géré par l’application de bureau.
Le partage d’une conversation entre les deux n’a pas été vérifié. Consultez la
[référence d’OpenAI sur la connexion de la TUI locale](https://learn.chatgpt.com/docs/app-server#connect-the-cli-terminal-ui).
Une fois que vous avez terminé, quittez la TUI, puis appuyez sur **Ctrl+C** dans le terminal de l’écouteur
et dans celui du transfert. Suivez ensuite
[Se reconnecter et arrêter la sandbox SSH](#reconnect-and-stop-the-ssh-sandbox)
pour récupérer les fichiers et arrêter les ressources de calcul.
Utiliser les applications de bureau et mobiles
Suivez d’abord la procédure [Créer une sandbox accessible en SSH](#create-an-ssh-accessible-sandbox).
Ajoutez la sandbox comme projet SSH dans l’application de bureau, puis utilisez Remote pour
reprendre votre travail depuis un téléphone associé. C’est l’hôte de bureau qui maintient la connexion SSH.
Connecter l’application de bureau
Ajoutez la sandbox en tant que projet distant, puis vérifiez que Codex écrit bien dans son
système de fichiers.
1. Dans le fichier `~/.ssh/cw-codex-session/ssh_config`, copiez le bloc
`Host cw-codex` généré. Dans le fichier `~/.ssh/config`, collez-le avant les valeurs par défaut `Host *`, le cas échéant.
Si une entrée `Host cw-codex` existe déjà, remplacez-la au lieu d’en créer un doublon.
2. Exécutez `ssh cw-codex 'codex --version'`. Corrigez les éventuelles erreurs d’authentification ou de clé d’hôte
avant de poursuivre.
3. Dans l’application de bureau, ouvrez **Settings > Connections**, puis ajoutez ou activez
l’hôte SSH `cw-codex`.
4. Choisissez `/workspace/project` comme dossier de projet distant, puis enregistrez le projet.
5. Ouvrez ce projet distant et démarrez une conversation. Demandez à Codex d’écrire une valeur unique
et non secrète dans le fichier `/workspace/project/sandbox-proof.txt`.
6. Depuis votre terminal, vérifiez le résultat de manière indépendante :
```bash theme={"system"}
ssh cw-codex 'cat /workspace/project/sandbox-proof.txt'
```
Le contenu du fichier doit correspondre à la valeur demandée.
L’application de bureau lance le serveur d’application distant via le shell de connexion de l’utilisateur SSH. Codex
doit être installé et authentifié pour cet utilisateur. Voir la documentation d’OpenAI sur la
[configuration SSH de l’application de bureau](https://learn.chatgpt.com/docs/remote-connections#connect-to-an-ssh-host).
Mobile et autre ordinateur via Remote
La fonctionnalité Remote d’OpenAI relie les applications de bureau et mobiles prises en charge par l’intermédiaire d’un
hôte appairé. D’après la documentation, la configuration mobile commence dans l’application de bureau ChatGPT sur un
hôte Mac ou Windows, avec le même compte et le même Workspace sur les deux appareils.
Les paramètres de l’organisation et la disponibilité de l’enregistrement de session peuvent restreindre l’accès.
Pour travailler dans la sandbox depuis votre téléphone, connectez d’abord cet hôte de bureau au
projet SSH de la sandbox. Appairez ensuite votre téléphone avec l’hôte de bureau. Dans ChatGPT
sur iOS ou Android, utilisez **Remote**. Votre téléphone se connecte à l’hôte de bureau, qui
lui-même se connecte à la sandbox. L’application de bureau doit rester ouverte, active et
en ligne. Une autre application de bureau Mac ou Windows prise en charge peut se connecter au même
hôte lorsque **Control other devices** est disponible.
Suivez les [instructions de configuration de Remote](https://learn.chatgpt.com/docs/remote-connections) d’OpenAI.
Une URL WebSocket de serveur d’application n’est pas une URL d’appairage mobile. De même, la connexion
`codex exec-server --remote` de l’API Agents ne permet pas d’appairer un appareil mobile.
Continuité des sessions et autres points d’entrée
Remote permet de poursuivre les chats d’un hôte connecté depuis des appareils associés. Cela
ne garantit pas pour autant qu’une conversation démarrée avec l’exemple direct `codex --remote`
apparaisse dans un projet SSH de bureau configuré séparément. Considérez
ce transfert de session d’une interface à l’autre comme non vérifié pour cette configuration.
La configuration Remote publiée répertorie les clients mobiles et les clients de bureau pris en charge. Elle ne
documente pas la manière de joindre le site web de ChatGPT ou de Codex à cette session de sandbox. L’accès
via le site web n’entre pas dans le périmètre des interfaces couvertes par ce guide.
Certaines compilations de Codex proposent les commandes expérimentales `codex remote-control start` et
`codex remote-control pair`. Elles gèrent un démon de serveur d’application ainsi que l’association,
mais les instructions mobiles publiées ne décrivent aucun flux d’association pris en charge pour une sandbox Linux
sans interface graphique. Ce guide ne les considère pas comme un équivalent vérifié de
Claude Remote Control. Consultez l’aide de la CLI installée et les recommandations actuelles d’OpenAI
avant de vous y fier.
Vérifier la session
Si vous avez suivi [Exécuter Codex CLI dans un sandbox](#run-codex-cli-in-a-sandbox) ou
[Connecter votre CLI locale au serveur d’application Codex](#connect-your-local-cli-to-codex-app-server), vérifiez que
Codex écrit bien dans le système de fichiers du sandbox. Pour un accès depuis l’application de bureau, suivez
[Connecter l’application de bureau](#connect-the-desktop-app).
Remplacez `[PROOF-VALUE]` par une valeur unique et non secrète, puis envoyez le prompt suivant dans
la TUI Codex connectée :
```text theme={"system"}
Écrivez le texte exact [PROOF-VALUE] dans /workspace/project/sandbox-proof.txt, puis relisez-le.
```
Si vous y êtes invité, approuvez l'écriture. Quittez la TUI, puis vérifiez le fichier séparément
depuis votre terminal local à l'aide de la commande correspondant à votre configuration :
```bash theme={"system"}
cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt'
```
```bash theme={"system"}
ssh -F ~/.ssh/cw-codex-session/ssh_config cw-codex 'cat /workspace/project/sandbox-proof.txt'
```
Si la valeur correspond, l'agent a bien écrit dans le système de fichiers de ce sandbox.
Cela ne prouve en revanche ni l'appairage mobile ni l'accès depuis une autre application.
Se reconnecter à la sandbox SSH et l’arrêter
Tant que la sandbox est en cours d’exécution, utilisez le même hôte `cw-codex` et le même projet.
La fermeture d’une connexion SSH ou de l’application de bureau n’arrête pas les ressources de calcul de la sandbox.
Avant d’arrêter la sandbox, enregistrez votre travail dans Git ou copiez les fichiers dont vous avez besoin :
```bash theme={"system"}
scp -F ~/.ssh/cw-codex-session/ssh_config cw-codex:/workspace/project/sandbox-proof.txt ./sandbox-proof.txt
```
Arrêtez la sandbox à l’aide de son ID enregistré :
```python theme={"system"}
from pathlib import Path
from cwsandbox import Sandbox
sandbox_id = Path("~/.ssh/cw-codex-session/sandbox-id").expanduser().read_text().strip()
sandbox = Sandbox.from_id(sandbox_id).result()
sandbox.stop().result()
```
Cet exemple n’utilise ni volume persistant ni instantané. L’arrêt ou l’expiration de la sandbox supprime
l’accès à ses fichiers, à son état de connexion et à son point de terminaison. Pour recommencer, créez une nouvelle
sandbox et un nouveau répertoire de sortie, puis remplacez le bloc `Host cw-codex` par la nouvelle
configuration. Chaque sandbox dispose de son propre point de terminaison, de son propre certificat TLS et de sa propre clé d’hôte SSH.
Conserver les résultats et arrêter
Pour la CLI locale et l’application de bureau, suivez
[Se reconnecter à la sandbox SSH et l’arrêter](#reconnect-and-stop-the-ssh-sandbox).
Pour `cws-agent`, enregistrez un instantané du Workspace et arrêtez les ressources de calcul :
```bash theme={"system"}
cws-agent down [SANDBOX-NAME]
```
Si la création de l’instantané échoue, examinez l’erreur signalée avant de faire une nouvelle tentative. Pour arrêter
sans enregistrer, utilisez `cws-agent down [SANDBOX-NAME] --no-snapshot`.
Quitter la TUI n'arrête pas les ressources de calcul. Lorsque vous arrêtez la sandbox ou qu’elle expire,
ses processus prennent fin. Pour relancer le calcul, restaurez les fichiers enregistrés, puis redémarrez Codex.
Les instantanés ne conservent pas les processus en cours d’exécution. Lorsque vous choisissez les éléments à conserver, traitez les fichiers d’authentification
et de session Codex enregistrés comme des données sensibles.
Dépannage
Effectuez les vérifications suivantes pour résoudre les problèmes courants :
* L’authentification échoue : distinguez les identifiants d’authentification utilisés pour le provisionnement de la sandbox, l’authentification
au modèle Codex et les clés SSH. Chacun a un rôle différent.
* Les options du serveur d’application sont rejetées : comparez la sortie de `codex --version` en local et dans la
sandbox. L’exemple de CLI locale nécessite les options WebSocket documentées.
* La TUI se connecte, mais les tâches échouent : vérifiez l’accès au modèle, la facturation, la confiance accordée au Workspace
et les paramètres d’approbation. Une connexion de transport établie ne garantit pas à elle seule l’accès au modèle.
* La connexion est interrompue : reconnectez-vous tant que la sandbox est en cours d’exécution. Les délais d’expiration du point de terminaison ou
du transport ne prolongent pas sa durée de vie et ne garantissent pas qu’un tour de conversation en cours a abouti.
* Remote n’est pas disponible dans l’application mobile : vérifiez les exigences d’OpenAI concernant le compte, le Workspace,
l’hôte et l’enregistrement de session. Le simple démarrage du serveur d’application ne suffit pas à l’activer.