Claude Code

Обновление образов

Готовые образы агентов обновляются каждое утро и содержат актуальную версию CLI. Чтобы использовать фиксированную версию образа, закрепите версию шаблона.

Claude Code — агент Anthropic, который читает и изменяет файлы, выполняет команды и подключает внешние инструменты. В AgentBox он работает внутри отдельной песочницы. В шаблоне claude CLI уже установлен.

Подключение

Установите SDK AgentBox и задайте AGENTBOX_API_KEY и ANTHROPIC_API_KEY в окружении приложения. Пример передаёт ключ Anthropic только команде агента. --model sonnet выбирает модель по алиасу Claude Code. Вместо него можно указать полное имя модели, доступной вашему ключу.

Для доступа к модели можно использовать HTTPS-прокси AgentBox https://sandbox-proxy.agentbox.ru:65181.

Переменные HTTPS_PROXY, HTTP_PROXY и NO_PROXY передаются только команде агента и наследуются её дочерними процессами. Это общие настройки сети процесса: другие запросы агента тоже могут идти через прокси. NO_PROXY оставляет соединения с localhost и 127.0.0.1 прямыми.

Сравните прайс-листы

Пример загружает два CSV с ценами поставщика. Claude сопоставляет товары по артикулу и записывает changes.md: изменения в рублях и процентах, прежние цены и новые позиции. В этих данных A-100 дорожает на 200 ₽ (20%), B-200 не меняется, C-300 появляется впервые.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.ANTHROPIC_API_KEY;
if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("claude", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/prices-before.csv",
    "sku,price_rub\nA-100,1000\nB-200,2500\n",
  );
  await sandbox.files.write(
    "/home/user/work/prices-after.csv",
    "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
  );
  const handle = await sandbox.commands.run(
    "claude -p --model sonnet --dangerously-skip-permissions --output-format json",
    {
      cwd: "/home/user/work",
      timeoutMs: 300_000,
      background: true,
      stdin: true,
      envs: {
        ANTHROPIC_API_KEY: apiKey,
        HTTPS_PROXY: proxy,
        HTTP_PROXY: proxy,
        NO_PROXY: "localhost,127.0.0.1",
      },
      onStderr: (chunk) => process.stderr.write(chunk),
    },
  );
  await handle.sendStdin(
    "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items. Use only the supplied data.",
  );
  await handle.closeStdin();
  const result = await handle.wait();
  const response = JSON.parse(result.stdout);
  if (response.is_error) throw new Error(response.result ?? response.subtype);
  console.log(response.result);
  console.log(
    "changes.md\n" + (await sandbox.files.read("/home/user/work/changes.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["ANTHROPIC_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("claude", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n"
    )
    sandbox.files.write(
        "/home/user/work/prices-after.csv",
        "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
    )
    handle = sandbox.commands.run(
        "claude -p --model sonnet --dangerously-skip-permissions --output-format json",
        cwd="/home/user/work",
        timeout=300,
        background=True,
        stdin=True,
        envs={
            "ANTHROPIC_API_KEY": api_key,
            "HTTPS_PROXY": proxy,
            "HTTP_PROXY": proxy,
            "NO_PROXY": "localhost,127.0.0.1",
        },
    )
    handle.send_stdin(
        "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items. Use only the supplied data."
    )
    handle.close_stdin()
    result = handle.wait(on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr))
    response = json.loads(result.stdout)
    if response["is_error"]:
        raise RuntimeError(response.get("result") or response["subtype"])
    print(response["result"])
    print("changes.md\n" + sandbox.files.read("/home/user/work/changes.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"github.com/abox-dev/sdk/packages/go-sdk"
	"log"
	"os"
	"time"
)

func run() (err error) {
	apiKey, proxy := os.Getenv("ANTHROPIC_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("ANTHROPIC_API_KEY is required")
	}
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "claude", Timeout: 10 * time.Minute})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n", nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/prices-after.csv", "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n", nil); err != nil {
		return err
	}
	handle, err := sandbox.Commands.Start(ctx, "sh", &agentbox.CommandOptions{
		Args: []string{"-lc", "claude -p --model sonnet --dangerously-skip-permissions --output-format json"}, Cwd: "/home/user/work", Stdin: true,
		Env:      map[string]string{"ANTHROPIC_API_KEY": apiKey, "HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
		OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
	})
	if err != nil {
		return err
	}
	if _, err := handle.Write(ctx, []byte("Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items. Use only the supplied data.")); err != nil {
		return err
	}
	if err := handle.CloseStdin(ctx); err != nil {
		return err
	}
	result, err := handle.Wait(ctx)
	if err != nil {
		return err
	}
	var response struct {
		IsError bool   `json:"is_error"`
		Result  string `json:"result"`
		Subtype string `json:"subtype"`
	}
	if err := json.Unmarshal(result.Stdout, &response); err != nil {
		return err
	}
	if response.IsError {
		return fmt.Errorf("Claude Code: %s: %s", response.Subtype, response.Result)
	}
	fmt.Println(response.Result)
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/changes.md", "")
	if err != nil {
		return err
	}
	fmt.Println("changes.md\n" + report)
	return nil
}
func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

-p выполняет задание и завершает процесс. Приложение передаёт текст задания через stdin и закрывает ввод, затем дожидается результата. --dangerously-skip-permissions отключает запросы подтверждения и проверки разрешений Claude Code. Агент использует стандартный набор инструментов. Границей изоляции служит песочница AgentBox.

--output-format json возвращает текст в result, идентификатор session_id и признак ошибки is_error. Пример проверяет этот признак и читает готовый файл через SDK. Блок finally удаляет песочницу и при ошибке.

Получите результат и продолжите сессию

Следующий пример выводит ответ по мере генерации. Сначала Claude сравнивает прайс-листы, затем получает второй запрос: добавить стоимость закупки по 10 штук каждого прежнего товара. История и файлы остаются в той же песочнице.

mjs

import { Sandbox } from "@abox-dev/sdk";

const apiKey = process.env.ANTHROPIC_API_KEY;
if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required");
const proxy =
  process.env.SANDBOX_PROXY_URL ?? "https://sandbox-proxy.agentbox.ru:65181";
const sandbox = await Sandbox.create("claude", { timeoutMs: 600_000 });
try {
  await sandbox.files.makeDir("/home/user/work");
  await sandbox.files.write(
    "/home/user/work/prices-before.csv",
    "sku,price_rub\nA-100,1000\nB-200,2500\n",
  );
  await sandbox.files.write(
    "/home/user/work/prices-after.csv",
    "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
  );
  async function execute(prompt, sessionId) {
    let pending = "";
    let result;
    let nextSessionId;
    function event(message) {
      if (
        message.type === "stream_event" &&
        message.event.delta?.type === "text_delta"
      ) {
        process.stdout.write(message.event.delta.text);
      }
      if (message.type === "result") result = message;
    }
    function onStdout(chunk) {
      pending += chunk;
      let newline;
      while ((newline = pending.indexOf("\n")) !== -1) {
        const line = pending.slice(0, newline);
        pending = pending.slice(newline + 1);
        if (line.trim()) event(JSON.parse(line));
      }
    }
    const handle = await sandbox.commands.run(
      "claude -p --model sonnet --dangerously-skip-permissions --output-format stream-json --verbose --include-partial-messages" +
        (sessionId ? ' --resume "$AGENT_SESSION_ID"' : ""),
      {
        cwd: "/home/user/work",
        timeoutMs: 300_000,
        background: true,
        stdin: true,
        envs: {
          ANTHROPIC_API_KEY: apiKey,
          HTTPS_PROXY: proxy,
          HTTP_PROXY: proxy,
          NO_PROXY: "localhost,127.0.0.1",
          AGENT_SESSION_ID: sessionId ?? "",
        },
        onStdout,
        onStderr: (chunk) => process.stderr.write(chunk),
      },
    );
    await handle.sendStdin(prompt);
    await handle.closeStdin();
    await handle.wait();
    if (pending.trim()) event(JSON.parse(pending));
    if (!result) throw new Error("Claude Code ended without a result");
    if (result.is_error)
      throw new Error(
        result.result ?? result.errors?.join("\n") ?? result.subtype,
      );
    nextSessionId = result.session_id;
    if (!nextSessionId)
      throw new Error("Claude Code did not return a session ID");
    console.log("\nSession:", nextSessionId);
    return nextSessionId;
  }
  const sessionId = await execute(
    "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items.",
  );
  await execute(
    "Add a procurement summary to changes.md: calculate the cost of 10 units of each existing item before and after the change. Keep the original comparison.",
    sessionId,
  );
  console.log(
    "changes.md\n" + (await sandbox.files.read("/home/user/work/changes.md")),
  );
} finally {
  await sandbox.kill();
}

import json
import os
import sys
from agentbox import Sandbox

api_key = os.environ["ANTHROPIC_API_KEY"]
proxy = os.getenv("SANDBOX_PROXY_URL", "https://sandbox-proxy.agentbox.ru:65181")
sandbox = Sandbox.create("claude", timeout=600)
try:
    sandbox.files.make_dir("/home/user/work")
    sandbox.files.write(
        "/home/user/work/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n"
    )
    sandbox.files.write(
        "/home/user/work/prices-after.csv",
        "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n",
    )

    def execute(prompt, session_id=None):
        pending = ""
        result = None
        next_session_id = None

        def event(message):
            nonlocal result
            if message["type"] == "stream_event":
                delta = message["event"].get("delta", {})
                if delta.get("type") == "text_delta":
                    print(delta["text"], end="", flush=True)
            elif message["type"] == "result":
                result = message

        def on_stdout(chunk):
            nonlocal pending
            pending += chunk
            while "\n" in pending:
                line, pending = pending.split("\n", 1)
                if line.strip():
                    event(json.loads(line))

        handle = sandbox.commands.run(
            "claude -p --model sonnet --dangerously-skip-permissions --output-format stream-json --verbose --include-partial-messages"
            + (' --resume "$AGENT_SESSION_ID"' if session_id else ""),
            cwd="/home/user/work",
            timeout=300,
            background=True,
            stdin=True,
            envs={
                "ANTHROPIC_API_KEY": api_key,
                "HTTPS_PROXY": proxy,
                "HTTP_PROXY": proxy,
                "NO_PROXY": "localhost,127.0.0.1",
                "AGENT_SESSION_ID": session_id or "",
            },
        )
        handle.send_stdin(prompt)
        handle.close_stdin()
        handle.wait(
            on_stdout=on_stdout,
            on_stderr=lambda chunk: print(chunk, end="", file=sys.stderr),
        )
        if pending.strip():
            event(json.loads(pending))
        if result is None:
            raise RuntimeError("Claude Code ended without a result")
        if result["is_error"]:
            raise RuntimeError(
                result.get("result") or result.get("errors") or result["subtype"]
            )
        next_session_id = result.get("session_id")
        if not next_session_id:
            raise RuntimeError("Claude Code did not return a session ID")
        print("\nSession:", next_session_id)
        return next_session_id

    session_id = execute(
        "Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items."
    )
    execute(
        "Add a procurement summary to changes.md: calculate the cost of 10 units of each existing item before and after the change. Keep the original comparison.",
        session_id,
    )
    print("changes.md\n" + sandbox.files.read("/home/user/work/changes.md"))
finally:
    sandbox.kill()

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"
	"strings"
	"time"

	"github.com/abox-dev/sdk/packages/go-sdk"
)

func run() (err error) {
	apiKey, proxy := os.Getenv("ANTHROPIC_API_KEY"), os.Getenv("SANDBOX_PROXY_URL")
	if apiKey == "" {
		return errors.New("ANTHROPIC_API_KEY is required")
	}
	if proxy == "" {
		proxy = "https://sandbox-proxy.agentbox.ru:65181"
	}
	ctx, cancel := context.WithTimeout(context.Background(), 8*time.Minute)
	defer cancel()
	client, err := agentbox.NewClient()
	if err != nil {
		return err
	}
	sandbox, err := client.Sandboxes.Create(ctx, &agentbox.CreateSandboxOptions{Template: "claude", Timeout: 10 * time.Minute})
	if err != nil {
		return err
	}
	defer func() {
		cleanupCtx, stop := context.WithTimeout(context.Background(), 30*time.Second)
		defer stop()
		_, cleanupErr := sandbox.Kill(cleanupCtx)
		err = errors.Join(err, cleanupErr)
	}()
	if _, err := sandbox.Files.MakeDir(ctx, "/home/user/work"); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/prices-before.csv", "sku,price_rub\nA-100,1000\nB-200,2500\n", nil); err != nil {
		return err
	}
	if _, err := sandbox.Files.WriteText(ctx, "/home/user/work/prices-after.csv", "sku,price_rub\nA-100,1200\nB-200,2500\nC-300,800\n", nil); err != nil {
		return err
	}
	execute := func(prompt, sessionID string) (string, error) {
		var pending, nextSessionID string
		var streamErr error
		var result *struct {
			IsError   bool     `json:"is_error"`
			Result    string   `json:"result"`
			Subtype   string   `json:"subtype"`
			SessionID string   `json:"session_id"`
			Errors    []string `json:"errors"`
		}
		event := func(line string) {
			if strings.TrimSpace(line) == "" || streamErr != nil {
				return
			}
			var message struct {
				Type  string `json:"type"`
				Event struct {
					Delta struct {
						Type string `json:"type"`
						Text string `json:"text"`
					} `json:"delta"`
				} `json:"event"`
			}
			if err := json.Unmarshal([]byte(line), &message); err != nil {
				streamErr = err
				return
			}
			if message.Type == "stream_event" && message.Event.Delta.Type == "text_delta" {
				fmt.Print(message.Event.Delta.Text)
			}
			if message.Type == "result" {
				streamErr = json.Unmarshal([]byte(line), &result)
			}
		}
		commandCtx, stopCommand := context.WithTimeout(ctx, 5*time.Minute)
		defer stopCommand()
		args := []string{"-p", "--model", "sonnet", "--dangerously-skip-permissions", "--output-format", "stream-json", "--verbose", "--include-partial-messages"}
		if sessionID != "" {
			args = append(args, "--resume", sessionID)
		}
		handle, err := sandbox.Commands.Start(commandCtx, "claude", &agentbox.CommandOptions{
			Args: args, Cwd: "/home/user/work", Stdin: true,
			Env: map[string]string{"ANTHROPIC_API_KEY": apiKey, "HTTPS_PROXY": proxy, "HTTP_PROXY": proxy, "NO_PROXY": "localhost,127.0.0.1"},
			OnStdout: func(chunk []byte) {
				pending += string(chunk)
				for {
					line, rest, found := strings.Cut(pending, "\n")
					if !found {
						break
					}
					pending = rest
					event(line)
				}
			},
			OnStderr: func(chunk []byte) { fmt.Fprint(os.Stderr, string(chunk)) },
		})
		if err != nil {
			return "", err
		}
		if _, err := handle.Write(commandCtx, []byte(prompt)); err != nil {
			return "", err
		}
		if err := handle.CloseStdin(commandCtx); err != nil {
			return "", err
		}
		if _, err := handle.Wait(commandCtx); err != nil {
			return "", err
		}
		event(pending)
		if streamErr != nil {
			return "", streamErr
		}
		if result == nil {
			return "", errors.New("Claude Code ended without a result")
		}
		if result.IsError {
			return "", fmt.Errorf("Claude Code: %s: %s %s", result.Subtype, result.Result, strings.Join(result.Errors, "; "))
		}
		nextSessionID = result.SessionID
		if nextSessionID == "" {
			return "", errors.New("Claude Code did not return a session ID")
		}
		fmt.Println("\nSession:", nextSessionID)
		return nextSessionID, nil
	}
	sessionID, err := execute("Compare prices-before.csv and prices-after.csv by sku. Write changes.md with price changes in RUB and percent, unchanged items, and new items.", "")
	if err != nil {
		return err
	}
	if _, err := execute("Add a procurement summary to changes.md: calculate the cost of 10 units of each existing item before and after the change. Keep the original comparison.", sessionID); err != nil {
		return err
	}
	report, err := sandbox.Files.ReadText(ctx, "/home/user/work/changes.md", "")
	if err != nil {
		return err
	}
	fmt.Println("changes.md\n" + report)
	return nil
}

func main() {
	if err := run(); err != nil {
		log.Fatal(err)
	}
}

--output-format stream-json --verbose --include-partial-messages включает поток JSONL. Обработчик собирает целые строки из фрагментов stdout и выводит stream_event → event.delta.text, если тип фрагмента — text_delta.

Финальное событие result содержит is_error и session_id. После успешного завершения команды приложение передаёт этот ID в --resume и отправляет новое задание через stdin. Второй процесс продолжает тот же разговор. Песочница удаляется после чтения дополненного changes.md.

Для этих данных стоимость 10 штук A-100 и B-200 вырастет с 35 000 ₽ до 37 000 ₽. Новая позиция C-300 остаётся в сравнении, но не входит в этот расчёт. Другие параметры описаны в руководстве Claude Code.

Claude Code ​

Подключение ​

Сравните прайс-листы ​

Получите результат и продолжите сессию ​

Claude Code

Подключение

Сравните прайс-листы

Получите результат и продолжите сессию