Git

Main class for a new Git handler instance.

Constructors

new Git()

def initialize(sandbox_id:, toolbox_api:, otel_state: nil)

Initializes a new Git handler instance.

Parameters:

sandbox_id String - The Sandbox ID.
toolbox_api DaytonaToolboxApiClient:GitApi - API client for Sandbox operations.
otel_state Daytona:OtelState, nil -

Returns:

Git - a new instance of Git

Methods

sandbox_id()

def sandbox_id()

Returns:

String - The Sandbox ID

toolbox_api()

def toolbox_api()

Returns:

DaytonaToolboxApiClient:GitApi - API client for Sandbox operations

add()

def add(path, files)

Stages the specified files for the next commit, similar to running ‘git add’ on the command line.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
files Array<String> - List of file paths or directories to stage, relative to the repository root.

Returns:

void

Raises:

Daytona:Sdk:Error - if adding files fails

Examples:

# Stage a single file
sandbox.git.add("workspace/repo", ["file.txt"])

# Stage multiple files
sandbox.git.add("workspace/repo", [
  "src/main.rb",
  "spec/main_spec.rb",
  "README.md"
])

branches()

def branches(path)

Lists branches in the repository.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.

Returns:

DaytonaApiClient:ListBranchResponse - List of branches in the repository.

Raises:

Daytona:Sdk:Error - if listing branches fails

Examples:

response = sandbox.git.branches("workspace/repo")
puts "Branches: #{response.branches}"

clone()

def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil, insecure_skip_tls: nil, depth: nil)

Clones a Git repository into the specified path. It supports cloning specific branches or commits, and can authenticate with the remote repository if credentials are provided.

Parameters:

url String - Repository URL to clone from.
path String - Path where the repository should be cloned. Relative paths are resolved based on the sandbox working directory.
branch String, nil - Specific branch to clone. If not specified, clones the default branch.
commit_id String, nil - Specific commit to clone. If specified, the repository will be left in a detached HEAD state at this commit.
username String, nil - Git username for authentication.
password String, nil - Git password or token for authentication.
insecure_skip_tls Boolean, nil - Skip TLS certificate verification (insecure). Use only for trusted internal Git servers with self-signed or private-CA certs; credentials, if supplied, are transmitted over an unverified TLS connection.
depth Integer, nil - Create a shallow clone truncated to the given number of commits.

Returns:

void

Raises:

Daytona:Sdk:Error - if cloning repository fails

Examples:

# Clone the default branch
sandbox.git.clone(
  url: "https://github.com/user/repo.git",
  path: "workspace/repo"
)

# Clone a specific branch with authentication
sandbox.git.clone(
  url: "https://github.com/user/private-repo.git",
  path: "workspace/private",
  branch: "develop",
  username: "user",
  password: "token"
)

# Clone a specific commit
sandbox.git.clone(
  url: "https://github.com/user/repo.git",
  path: "workspace/repo-old",
  commit_id: "abc123"
)

commit()

def commit(path:, message:, author:, email:, allow_empty: false)

Creates a new commit with the staged changes. Make sure to stage changes using the add() method before committing.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
message String - Commit message describing the changes.
author String - Name of the commit author.
email String - Email address of the commit author.
allow_empty Boolean - Allow creating an empty commit when no changes are staged. Defaults to false.

Returns:

GitCommitResponse - Response containing the commit SHA.

Raises:

Daytona:Sdk:Error - if committing changes fails

Examples:

# Stage and commit changes
sandbox.git.add("workspace/repo", ["README.md"])
commit_response = sandbox.git.commit(
  path: "workspace/repo",
  message: "Update documentation",
  author: "John Doe",
  email: "john@example.com",
  allow_empty: true
)
puts "Commit SHA: #{commit_response.sha}"

push()

def push(path:, username: nil, password: nil, branch: nil, remote: nil, set_upstream: false)

Pushes all local commits on the current branch to the remote repository. If the remote repository requires authentication, provide username and password/token.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
username String, nil - Git username for authentication.
password String, nil - Git password or token for authentication.
branch String, nil - Branch to push. Defaults to the current branch.
remote String, nil - Remote to push to. Defaults to “origin”.
set_upstream Boolean - Record the pushed branch as the upstream tracking branch. Defaults to false.

Returns:

void

Raises:

Daytona:Sdk:Error - if pushing changes fails

Examples:

# Push without authentication (for public repos or SSH)
sandbox.git.push("workspace/repo")

# Push with authentication
sandbox.git.push(
  path: "workspace/repo",
  username: "user",
  password: "github_token"
)

# Push a new branch and set its upstream
sandbox.git.push(path: "workspace/repo", branch: "feature", set_upstream: true)

pull()

def pull(path:, username: nil, password: nil, branch: nil, remote: nil)

Pulls changes from the remote repository. If the remote repository requires authentication, provide username and password/token.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
username String, nil - Git username for authentication.
password String, nil - Git password or token for authentication.
branch String, nil - Branch to pull. Defaults to the current branch’s upstream.
remote String, nil - Remote to pull from. Defaults to “origin”.

Returns:

void

Raises:

Daytona:Sdk:Error - if pulling changes fails

Examples:

# Pull without authentication
sandbox.git.pull("workspace/repo")

# Pull with authentication
sandbox.git.pull(
  path: "workspace/repo",
  username: "user",
  password: "github_token"
)

# Pull a specific branch from a specific remote
sandbox.git.pull(path: "workspace/repo", remote: "upstream", branch: "main")

status()

def status(path)

Gets the current Git repository status.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.

Returns:

DaytonaToolboxApiClient:GitStatus - Repository status information including:

Raises:

Daytona:Sdk:Error - if getting status fails

Examples:

status = sandbox.git.status("workspace/repo")
puts "On branch: #{status.current_branch}"
puts "Commits ahead: #{status.ahead}"
puts "Commits behind: #{status.behind}"

checkout_branch()

def checkout_branch(path, branch)

Checkout branch in the repository.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
branch String - Name of the branch to checkout

Returns:

void

Raises:

Daytona:Sdk:Error - if checking out branch fails

Examples:

# Checkout a branch
sandbox.git.checkout_branch("workspace/repo", "feature-branch")

create_branch()

def create_branch(path, name)

Create branch in the repository.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
name String - Name of the new branch to create

Returns:

void

Raises:

Daytona:Sdk:Error - if creating branch fails

Examples:

# Create a new branch
sandbox.git.create_branch("workspace/repo", "new-feature")

delete_branch()

def delete_branch(path, name)

Delete branch in the repository.

Parameters:

path String - Path to the Git repository root. Relative paths are resolved based on the sandbox working directory.
name String - Name of the branch to delete

Returns:

void

Raises:

Daytona:Sdk:Error - if deleting branch fails

Examples:

# Delete a branch
sandbox.git.delete_branch("workspace/repo", "old-feature")

init()

def init(path, bare: false, initial_branch: nil)

Initializes a new Git repository at the specified path.

Parameters:

path String - Path where the repository should be initialized.
bare Boolean - Create a bare repository without a working tree. Defaults to false.
initial_branch String, nil - Name of the initial branch. If not specified, uses the Git default.

Returns:

void

Raises:

Daytona:Sdk:Error - if initializing repository fails

Examples:

sandbox.git.init("workspace/repo", initial_branch: "main")

reset()

def reset(path, mode: nil, target: nil, files: nil)

Resets the current HEAD to the specified state.

Parameters:

path String - Path to the Git repository root.
mode String, nil - Reset mode, one of “soft”, “mixed” (default), “hard”, “merge” or “keep”.
target String, nil - Revision to reset to. Defaults to HEAD.
files Array<String>, nil - Constrain the reset to the given paths.

Returns:

void

Raises:

Daytona:Sdk:Error - if resetting fails

Examples:

# Unstage all changes (mixed reset to HEAD)
sandbox.git.reset("workspace/repo")

# Hard reset to a previous commit
sandbox.git.reset("workspace/repo", mode: "hard", target: "HEAD~1")

restore()

def restore(path, files, staged: nil, worktree: nil, source: nil)

Restores working tree files or unstages changes.

Parameters:

path String - Path to the Git repository root.
files Array<String> - File paths to restore.
staged Boolean, nil - Restore the staging index for the given files.
worktree Boolean, nil - Restore the working tree for the given files. Defaults to true when neither staged nor worktree is provided.
source String, nil - Restore file contents from the given revision instead of the index.

Returns:

void

Raises:

Daytona:Sdk:Error - if restoring fails

Examples:

# Discard working tree changes
sandbox.git.restore("workspace/repo", ["file.txt"])

# Unstage changes
sandbox.git.restore("workspace/repo", ["file.txt"], staged: true)

remote_add()

def remote_add(path, name, url, fetch: false, overwrite: false)

Adds (or overwrites) a remote in the repository.

Parameters:

path String - Path to the Git repository root.
name String - Name of the remote.
url String - URL of the remote.
fetch Boolean - Fetch from the remote immediately after adding it. Defaults to false.
overwrite Boolean - Replace an existing remote with the same name. Defaults to false.

Returns:

void

Raises:

Daytona:Sdk:Error - if adding the remote fails

Examples:

sandbox.git.remote_add("workspace/repo", "origin", "https://github.com/user/repo.git")

remotes()

def remotes(path)

Lists the remotes configured in the repository.

Parameters:

path String - Path to the Git repository root.

Returns:

DaytonaToolboxApiClient:ListRemotesResponse - The configured remotes (name + URL).

Raises:

Daytona:Sdk:Error - if listing remotes fails

Examples:

response = sandbox.git.remotes("workspace/repo")
response.remotes.each { |r| puts "#{r.name}: #{r.url}" }

remote_get()

def remote_get(path, name)

Gets the URL of a remote, or nil when it does not exist.

Parameters:

path String - Path to the Git repository root.
name String - Name of the remote.

Returns:

String, nil - The remote URL, or nil when the remote does not exist.

Raises:

Daytona:Sdk:Error - if getting the remote fails

Examples:

url = sandbox.git.remote_get("workspace/repo", "origin")

set_config()

def set_config(key, value, scope: 'global', path: nil)

Sets a Git config value at the given scope.

Parameters:

key String - Config key in dotted form (e.g. “user.name”).
value String - Config value.
scope String - Config scope, one of “global” (default), “local” or “system”.
path String, nil - Repository path, required when scope is “local”.

Returns:

void

Raises:

Daytona:Sdk:Error - if setting config fails

Examples:

sandbox.git.set_config("user.name", "John Doe")

get_config()

def get_config(key, scope: 'global', path: nil)

Gets a Git config value at the given scope, or nil when unset.

Parameters:

key String - Config key in dotted form (e.g. “user.name”).
scope String - Config scope, one of “global” (default), “local” or “system”.
path String, nil - Repository path, required when scope is “local”.

Returns:

String, nil - The config value, or nil when the key is not set.

Raises:

Daytona:Sdk:Error - if getting config fails

Examples:

name = sandbox.git.get_config("user.name")

configure_user()

def configure_user(name, email, scope: 'global', path: nil)

Configures the Git user name and email at the given scope.

Parameters:

name String - User name (user.name).
email String - User email (user.email).
scope String - Config scope, one of “global” (default), “local” or “system”.
path String, nil - Repository path, required when scope is “local”.

Returns:

void

Raises:

Daytona:Sdk:Error - if configuring user fails

Examples:

sandbox.git.configure_user("John Doe", "john@example.com")

dangerously_authenticate()

def dangerously_authenticate(username, password, host: nil, protocol: nil)

Persists Git credentials globally so that subsequent operations against the given host authenticate automatically.

WARNING: This stores the password in plaintext on disk via the Git credential store.

Parameters:

username String - Git username.
password String - Git password or token.
host String, nil - Host to authenticate against. Defaults to “github.com”.
protocol String, nil - Protocol to authenticate against. Defaults to “https”.

Returns:

void

Raises:

Daytona:Sdk:Error - if authenticating fails

Examples:

sandbox.git.dangerously_authenticate("user", "github_token")