@spec await(t(), String.t(), keyword()) ::
  {:ok, %{exit_code: integer(), command: String.t() | nil}}
  | {:error, ExDaytona.Error.t()}

Poll until the command finishes, then return {:ok, %{exit_code: integer, command: String.t()}}.

Options: :timeout (default 120_000 ms), :poll_interval (default 1_000 ms).

@spec command(t(), String.t()) ::
  {:ok, ExDaytona.Model.Command.t()} | {:error, ExDaytona.Error.t()}

A command's current state (ExDaytona.Model.Command) — exitCode is nil while it is still running.

@spec create(
  ExDaytona.Sandbox.t(),
  keyword()
) :: {:ok, t()} | {:error, ExDaytona.Error.t()}

Create a session in the sandbox.

Options: :id — the session id (default: a generated "ex-daytona-" id).

@spec delete(t()) :: :ok | {:error, ExDaytona.Error.t()}

Delete the session. Returns :ok.

@spec entrypoint(ExDaytona.Sandbox.t()) ::
  {:ok, ExDaytona.Model.Session.t()} | {:error, ExDaytona.Error.t()}

The sandbox's entrypoint session (where a configured entrypoint runs), as an ExDaytona.Model.Session.

@spec entrypoint_logs(ExDaytona.Sandbox.t()) ::
  {:ok, binary()} | {:error, ExDaytona.Error.t()}

The entrypoint's logs so far, as a binary (fetched raw — see logs/2 for why the generated operation is bypassed).

@spec get(t()) :: {:ok, ExDaytona.Model.Session.t()} | {:error, ExDaytona.Error.t()}

Fetch a session's current state (its command history) as an ExDaytona.Model.Session.

@spec list(ExDaytona.Sandbox.t()) ::
  {:ok, [ExDaytona.Model.Session.t()]} | {:error, ExDaytona.Error.t()}

List the sandbox's sessions as ExDaytona.Model.Session structs.

@spec logs(t(), String.t()) :: {:ok, binary()} | {:error, ExDaytona.Error.t()}

The logs a command has produced so far, as a binary (stdout and stderr merged, as the sandbox emits them).

Note: the OpenAPI spec declares a JSON model for this endpoint, but the live server returns text/plain — so this bypasses the generated operation and reads the raw body.

@spec open_log_stream(t(), String.t(), keyword()) ::
  {:ok, pid()} | {:error, ExDaytona.Error.t()}

Open a structured, bounded log stream for a command — separate :stdout/:stderr events over the provider's websocket protocol, pull-based via ExDaytona.LogStream.next/2. See ExDaytona.LogStream for the full contract (ownership, bounds, timeouts, close semantics).

Options are passed to ExDaytona.LogStream.open/3 (:owner, :max_buffer_bytes, :max_frames, :max_frame_bytes, :idle_timeout, :overall_timeout, :connect_timeout).

@spec run(t(), String.t()) ::
  {:ok,
   %{
     cmd_id: String.t() | nil,
     exit_code: integer() | nil,
     output: String.t() | nil,
     stdout: String.t() | nil,
     stderr: String.t() | nil
   }}
  | {:error, ExDaytona.Error.t()}

Run a command in the session and wait for it to finish.

Returns {:ok, %{cmd_id, exit_code, output, stdout, stderr}}.

@spec run_async(t(), String.t(), keyword()) ::
  {:ok, String.t()} | {:error, ExDaytona.Error.t()}

Start a command in the session without waiting. Returns {:ok, cmd_id} — follow it with stream_logs/4, logs/2, and await/3.

@spec send_input(t(), String.t(), iodata()) :: :ok | {:error, ExDaytona.Error.t()}

Send input to an interactive command's stdin (e.g. answering a confirmation prompt). Returns :ok.

@spec stream_logs(t(), String.t(), (binary() -> any()), keyword()) ::
  :ok | {:error, ExDaytona.Error.t()}

Follow a command's logs in real time: fun is invoked with each chunk as the sandbox produces it, and the call returns :ok when the stream closes (the command finished). Returning :halt from fun cancels the stream.

Options: :timeout — max milliseconds to wait between chunks (default :infinity); :deadline — overall milliseconds for the stream.