Claude Code

​

Prérequis

• Un jeton d’accès à l’API CoreWeave disposant de l’action SANDBOX_USER.
• Pour l’interface en terminal, un compte Claude ou des identifiants d’authentification API pris en charge par Claude Code. Pour Remote Control, un abonnement Claude Pro, Max, Team ou Enterprise. Les clés API et les jetons claude setup-token ne permettent pas de s’authentifier auprès de Remote Control.
• Une URL de dépôt que la sandbox peut cloner. Les exemples utilisent un dépôt public. Pour les dépôts privés, des identifiants d’authentification Git doivent être disponibles dans la sandbox.

export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"

​

Démarrage rapide avec cws-agent

​

Utiliser l’interface du terminal

cws-agent launch [SANDBOX-NAME] --repo-url [REPOSITORY-URL] --lifetime 8h --permission-mode native

cws-agent connect [SANDBOX-NAME] --cmd 'unset IS_DEMO; exec claude'

​

Utiliser Remote Control

cws-agent launch [SANDBOX-NAME] --repo-url [REPOSITORY-URL] --lifetime 8h --detach
cws-agent connect [SANDBOX-NAME] --cmd 'unset IS_DEMO CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_API_KEY; exec claude'

cws-agent rc [SANDBOX-NAME] --permission-mode native

cws-agent exec [SANDBOX-NAME] 'cat /workspace/home/remote-control.log'

cws-agent exec [SANDBOX-NAME] 'tmux kill-session -t cws-remote-control'
cws-agent connect [SANDBOX-NAME] --cmd 'tmux new-session -s cws-remote-control'

unset IS_DEMO CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC CLAUDE_CODE_OAUTH_TOKEN ANTHROPIC_API_KEY
cd /workspace/project
claude remote-control --spawn same-dir

​

Configurer avec le SDK Sandboxes

​

Créer la sandbox

uv venv --python 3.11
source .venv/bin/activate
uv pip install 'cwsandbox>=1.14.2'

npm install @coreweave/cwsandbox@0.5.0-beta.0 tsx

import sys

from cwsandbox import Sandbox

bootstrap = """
set -o pipefail
apt-get update -qq
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq tmux >/dev/null
curl -fsSL https://claude.ai/install.sh | bash
mkdir -p /workspace
"""

sandbox = Sandbox.run(
    container_image="node:22-bookworm",
    resources={"cpu": "2", "memory": "4Gi"},
    max_lifetime_seconds=8 * 3600,
    tags=["claude-code"],
)
try:
    sandbox.wait()
    commands = [
        ["bash", "-ec", bootstrap],
        ["git", "clone", "--", sys.argv[1], "/workspace/project"],
    ]
    for command in commands:
        result = sandbox.exec(command, timeout_seconds=900).result()
        if result.returncode != 0:
            raise RuntimeError(result.stderr or result.stdout)
except BaseException:
    sandbox.stop().result()
    raise

print(f"Sandbox ID: {sandbox.sandbox_id}")

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

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

const bootstrap = `
set -o pipefail
apt-get update -qq
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq tmux >/dev/null
curl -fsSL https://claude.ai/install.sh | bash
mkdir -p /workspace
`;

const client = createSandboxClientFromEnv();
const sandbox = await client.create({
  containerImage: "node:22-bookworm",
  resources: { cpu: "2", memory: "4Gi" },
  maxLifetimeSeconds: 8 * 3600,
  waitUntilRunning: false,
  tags: ["claude-code"],
});
try {
  await sandbox.wait();
  const commands = [
    ["bash", "-ec", bootstrap],
    ["git", "clone", "--", repository, "/workspace/project"],
  ];
  for (const command of commands) {
    await sandbox.commands.run(command, { timeoutMs: 900_000, check: true });
  }
} catch (error) {
  await sandbox.stop();
  throw error;
}
console.log(`Sandbox ID: ${sandbox.sandboxId}`);

python create_claude_sandbox.py [REPOSITORY-URL]

npx tsx create_claude_sandbox.mts [REPOSITORY-URL]

​

Connecter votre terminal

import os
import shutil
import sys
import termios
import threading
import tty

from cwsandbox import Sandbox

if not sys.stdin.isatty() or not sys.stdout.isatty():
    raise SystemExit("Run this script in an interactive terminal.")

sandbox = Sandbox.from_id(sys.argv[1]).result()
size = shutil.get_terminal_size()
terminal = sandbox.shell(["/bin/bash"], width=size.columns, height=size.lines)
fd = sys.stdin.fileno()
saved = termios.tcgetattr(fd)

def forward_input():
    while data := os.read(fd, 1024):
        terminal.stdin.write(data).result()
    terminal.stdin.close().result()

try:
    tty.setraw(fd)
    threading.Thread(target=forward_input, daemon=True).start()
    for chunk in terminal.output:
        sys.stdout.buffer.write(chunk)
        sys.stdout.buffer.flush()
    result = terminal.result()
finally:
    termios.tcsetattr(fd, termios.TCSADRAIN, saved)
    terminal.stdin.close().result()

raise SystemExit(result.returncode)

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

if (!process.stdin.isTTY || !process.stdout.isTTY) {
  throw new Error("Run this script in an interactive terminal.");
}
const sandboxId = process.argv[2];
if (!sandboxId) throw new Error("Pass a sandbox ID.");
const client = createSandboxClientFromEnv();
const sandbox = await client.fromId(sandboxId);
const terminal = await sandbox.shell({
  command: ["/bin/bash"],
  cols: process.stdout.columns || 80,
  rows: process.stdout.rows || 24,
});
const wasRaw = process.stdin.isRaw;
const forwardInput = (chunk: Buffer) => {
  void terminal.stdin.write(chunk).catch((error) => {
    console.error(error);
    void terminal.cancel();
  });
};

try {
  process.stdin.setRawMode(true);
  process.stdin.on("data", forwardInput);
  process.stdin.resume();
  for await (const chunk of terminal.output) {
    process.stdout.write(chunk);
  }
  const result = await terminal.wait();
  process.exitCode = result.exitCode;
} finally {
  process.stdin.off("data", forwardInput);
  process.stdin.setRawMode(wasRaw);
  process.stdin.pause();
  await terminal.stdin.close();
}

python attach_sandbox.py [SANDBOX-ID]

npx tsx attach_sandbox.mts [SANDBOX-ID]

​

Démarrer l’interface en mode terminal

read -r -s -p 'Anthropic API key: ' ANTHROPIC_API_KEY
export ANTHROPIC_API_KEY
printf '\n'

cd /workspace/project
/root/.local/bin/claude

​

Démarrer Remote Control

unset ANTHROPIC_API_KEY CLAUDE_CODE_OAUTH_TOKEN

cd /workspace/project
tmux new-session -s claude-remote

/root/.local/bin/claude

/root/.local/bin/claude remote-control --name "CoreWeave sandbox" --spawn same-dir

​

Vérifier la session

Écrivez le texte exact [PROOF-VALUE] dans /workspace/project/sandbox-proof.txt, puis relisez-le.

cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt'

from cwsandbox import Sandbox

sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
result = sandbox.exec(["cat", "/workspace/project/sandbox-proof.txt"], check=True).result()
print(result.stdout, end="")

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

const client = createSandboxClientFromEnv();
const sandbox = await client.fromId("[SANDBOX-ID]");
const result = await sandbox.commands.run(["cat", "/workspace/project/sandbox-proof.txt"], { check: true });
process.stdout.write(result.stdout);

​

Revenir à une sandbox en cours d’exécution

cws-agent list
cws-agent status [SANDBOX-NAME]
cws-agent connect [SANDBOX-NAME] --permission-mode native

cws-agent session history [SANDBOX-NAME]
cws-agent session resume [SANDBOX-NAME] [CONVERSATION-ID] --permission-mode native

​

Conserver les résultats et arrêter

cws-agent snapshot [SANDBOX-NAME]

cws-agent exec [SANDBOX-NAME] 'cat /workspace/project/sandbox-proof.txt' > sandbox-proof.txt

cws-agent down [SANDBOX-NAME]

from cwsandbox import Sandbox

sandbox = Sandbox.from_id("[SANDBOX-ID]").result()
sandbox.stop().result()

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

const client = createSandboxClientFromEnv();
const sandbox = await client.fromId("[SANDBOX-ID]");
await sandbox.stop();

cws-agent restore [SANDBOX-NAME] --lifetime 8h --connect --permission-mode native

​

Dépannage

• Si la création du sandbox échoue, vérifiez votre jeton d’accès à l’API CoreWeave et vos paramètres d’authentification.
• Si l’installation, le clonage ou les requêtes au modèle échouent, vérifiez la connectivité sortante et les identifiants d’authentification du fournisseur concerné. Pour le placement sur CoreWeave Kubernetes Service (CKS), la politique de votre exécuteur doit autoriser ces destinations.
• Si le terminal se déconnecte, rattachez-vous au sandbox tant qu’il est en cours d’exécution. Pour qu’un processus survive aux déconnexions du terminal, exécutez-le dans un multiplexeur de terminal tel que tmux.
• Si Remote Control rejette l’authentification, connectez-vous avec un abonnement Claude. Supprimez de l’environnement distant ou des paramètres de Claude les identifiants d’authentification par clé API qui entrent en conflit.
• Si Remote Control n’est pas disponible, consultez les instructions de dépannage d’Anthropic concernant les paramètres de l’organisation, les points de terminaison d’API personnalisés et les variables d’environnement qui désactivent des vérifications de fonctionnalités requises.
• Si le sandbox expire, créez-en un nouveau. Sa durée de vie ne peut pas être prolongée après sa création, et cet exemple de SDK n’enregistre pas automatiquement son système de fichiers.

​

Gestion des données

​

Étapes suivantes

• Shells interactifs et TTY traite de l’accès au terminal depuis le SDK.
• Cycle de vie d’une sandbox aborde l’attente, la reconnexion et l’arrêt.
• Documentation de Claude Code explique la configuration de l’agent et l’authentification.