Integración con Git

Novita Sandbox expone helpers de sandbox.git para flujos de trabajo comunes de repositorios, como clonar, crear ramas, confirmar cambios, hacer pull, hacer push, administrar remotos y configurar Git.

Autenticación e identidad

Credenciales en línea

Para repositorios HTTPS privados, pasa tanto un nombre de usuario como una contraseña/token directamente en operaciones como push, pull o clone.

import { Sandbox } from 'novita-sandbox'

const sandbox = await Sandbox.create()

await sandbox.git.push(repoPath, {
  username: process.env.GIT_USERNAME,
  password: process.env.GIT_TOKEN,
})

await sandbox.git.pull(repoPath, {
  username: process.env.GIT_USERNAME,
  password: process.env.GIT_TOKEN,
})

from novita_sandbox.core import Sandbox
import os

sandbox = Sandbox.create()

sandbox.git.push(
    repo_path,
    username=os.environ.get("GIT_USERNAME"),
    password=os.environ.get("GIT_TOKEN"),
)

sandbox.git.pull(
    repo_path,
    username=os.environ.get("GIT_USERNAME"),
    password=os.environ.get("GIT_TOKEN"),
)

Autenticarse una vez con el helper de credenciales de Git

Puedes usar dangerouslyAuthenticate() en JavaScript o dangerously_authenticate() en Python para almacenar credenciales dentro del helper de credenciales del sandbox.

Las credenciales se escriben en disco dentro del sandbox y cualquier elemento con acceso al sandbox puede leerlas.

Las credenciales pueden almacenarse para GitHub de forma predeterminada o para un host HTTPS personalizado.

await sandbox.git.dangerouslyAuthenticate({
  username: process.env.GIT_USERNAME,
  password: process.env.GIT_TOKEN,
})

await sandbox.git.dangerouslyAuthenticate({
  username: process.env.GIT_USERNAME,
  password: process.env.GIT_TOKEN,
  host: 'git.example.com',
  protocol: 'https',
})

await sandbox.git.clone('https://git.example.com/org/repo.git', {
  path: '/home/user/repo',
})

await sandbox.git.push('/home/user/repo')

sandbox.git.dangerously_authenticate(
    username=os.environ.get("GIT_USERNAME"),
    password=os.environ.get("GIT_TOKEN"),
)

sandbox.git.dangerously_authenticate(
    username=os.environ.get("GIT_USERNAME"),
    password=os.environ.get("GIT_TOKEN"),
    host="git.example.com",
    protocol="https",
)

sandbox.git.clone(
    "https://git.example.com/org/repo.git",
    path="/home/user/repo",
)

sandbox.git.push("/home/user/repo")

Mantener las credenciales en la URL remota

De forma predeterminada, las credenciales se eliminan de la URL remota después de clonar. Para conservarlas en .git/config, establece dangerouslyStoreCredentials: true (JS) o dangerously_store_credentials=True (Python).

Las credenciales mantenidas en una URL remota permanecen en la configuración del repositorio y pueden ser leídas por procesos del sandbox.

await sandbox.git.clone('https://git.example.com/org/repo.git', {
  path: '/home/user/repo',
  username: process.env.GIT_USERNAME,
  password: process.env.GIT_TOKEN,
})

await sandbox.git.clone('https://git.example.com/org/repo.git', {
  path: '/home/user/repo',
  username: process.env.GIT_USERNAME,
  password: process.env.GIT_TOKEN,
  dangerouslyStoreCredentials: true,
})

sandbox.git.clone(
    "https://git.example.com/org/repo.git",
    path="/home/user/repo",
    username=os.environ.get("GIT_USERNAME"),
    password=os.environ.get("GIT_TOKEN"),
)

sandbox.git.clone(
    "https://git.example.com/org/repo.git",
    path="/home/user/repo",
    username=os.environ.get("GIT_USERNAME"),
    password=os.environ.get("GIT_TOKEN"),
    dangerously_store_credentials=True,
)

Configurar la identidad de commit

Puedes usar configureUser (JS) o configure_user (Python) para establecer los detalles del autor de commits de forma global o local para un repositorio.

await sandbox.git.configureUser('Novita Bot', 'bot@example.com')

await sandbox.git.configureUser('Novita Bot', 'bot@example.com', {
  scope: 'local',
  path: repoPath,
})

sandbox.git.configure_user("Novita Bot", "bot@example.com")

sandbox.git.configure_user(
    "Novita Bot",
    "bot@example.com",
    scope="local",
    path=repo_path,
)

Clonar repositorios

Las opciones de clonación admitidas incluyen la ruta de destino, la selección de rama, la profundidad, el nombre de usuario, la contraseña y el comportamiento de almacenamiento de credenciales.

await sandbox.git.clone(repoUrl, {
  path: repoPath,
})

await sandbox.git.clone(repoUrl, {
  path: repoPath,
  branch: 'main',
})

await sandbox.git.clone(repoUrl, {
  path: repoPath,
  depth: 1,
})

sandbox.git.clone(repo_url, path=repo_path)

sandbox.git.clone(repo_url, path=repo_path, branch="main")

sandbox.git.clone(repo_url, path=repo_path, depth=1)

Comprobar el estado del repositorio y las ramas

Puedes usar status() para inspeccionar la rama actual, los recuentos de ahead/behind y el estado de los archivos. Puedes usar branches() para obtener la lista de ramas y la rama actual.

const status = await sandbox.git.status(repoPath)
console.log(status.currentBranch)
console.log(status.ahead)
console.log(status.behind)
console.log(status.fileStatus)

const branches = await sandbox.git.branches(repoPath)
console.log(branches.currentBranch)
console.log(branches.branches)

status = sandbox.git.status(repo_path)
print(status.current_branch)
print(status.ahead)
print(status.behind)
print(status.file_status)

branches = sandbox.git.branches(repo_path)
print(branches.current_branch)
print(branches.branches)

Crear, cambiar y eliminar ramas

await sandbox.git.createBranch(repoPath, 'feature/new-docs')

await sandbox.git.checkoutBranch(repoPath, 'main')

await sandbox.git.deleteBranch(repoPath, 'feature/old-docs')

await sandbox.git.deleteBranch(repoPath, 'feature/stale-docs', {
  force: true,
})

sandbox.git.create_branch(repo_path, "feature/new-docs")

sandbox.git.checkout_branch(repo_path, "main")

sandbox.git.delete_branch(repo_path, "feature/old-docs")

sandbox.git.delete_branch(
    repo_path,
    "feature/stale-docs",
    force=True,
)

Preparar y confirmar cambios

Puedes usar add para preparar todos los cambios o archivos seleccionados. Puedes usar commit para crear commits. Las opciones incluyen nombre de autor personalizado, correo electrónico del autor y commits vacíos.

await sandbox.git.add(repoPath)

await sandbox.git.commit(repoPath, 'Initial commit')

await sandbox.git.add(repoPath, {
  files: ['README.md', 'src/index.ts'],
})

await sandbox.git.commit(repoPath, 'Docs sync', {
  authorName: 'Novita Bot',
  authorEmail: 'bot@example.com',
  allowEmpty: true,
})

sandbox.git.add(repo_path)

sandbox.git.commit(repo_path, "Initial commit")

sandbox.git.add(
    repo_path,
    files=["README.md", "src/index.ts"],
)

sandbox.git.commit(
    repo_path,
    "Docs sync",
    author_name="Novita Bot",
    author_email="bot@example.com",
    allow_empty=True,
)

Pull y push

push y pull pueden usar el upstream configurado de forma predeterminada. También puedes especificar la configuración de remoto, rama y upstream.

await sandbox.git.push(repoPath)

await sandbox.git.pull(repoPath)

await sandbox.git.push(repoPath, {
  remote: 'origin',
  branch: 'main',
  setUpstream: true,
})

await sandbox.git.pull(repoPath, {
  remote: 'origin',
  branch: 'main',
})

sandbox.git.push(repo_path)

sandbox.git.pull(repo_path)

sandbox.git.push(
    repo_path,
    remote="origin",
    branch="main",
    set_upstream=True,
)

sandbox.git.pull(
    repo_path,
    remote="origin",
    branch="main",
)

Administrar remotos

Puedes usar remoteAdd (JS) o remote_add (Python) para añadir remotos, opcionalmente hacer fetch después de añadirlos o sobrescribir un remoto existente.

await sandbox.git.remoteAdd(repoPath, 'origin', repoUrl)

await sandbox.git.remoteAdd(repoPath, 'origin', repoUrl, {
  fetch: true,
})

await sandbox.git.remoteAdd(repoPath, 'origin', repoUrl, {
  overwrite: true,
})

sandbox.git.remote_add(repo_path, "origin", repo_url)

sandbox.git.remote_add(
    repo_path,
    "origin",
    repo_url,
    fetch=True,
)

sandbox.git.remote_add(
    repo_path,
    "origin",
    repo_url,
    overwrite=True,
)

Configuración de Git

Puedes usar setConfig / set_config y getConfig / get_config para administrar la configuración de Git de forma global o por repositorio.

await sandbox.git.setConfig('pull.rebase', 'false')

const value = await sandbox.git.getConfig('pull.rebase')

await sandbox.git.setConfig('pull.rebase', 'false', {
  scope: 'local',
  path: repoPath,
})

const localValue = await sandbox.git.getConfig('pull.rebase', {
  scope: 'local',
  path: repoPath,
})

sandbox.git.set_config("pull.rebase", "false")

value = sandbox.git.get_config("pull.rebase")

sandbox.git.set_config(
    "pull.rebase",
    "false",
    scope="local",
    path=repo_path,
)

local_value = sandbox.git.get_config(
    "pull.rebase",
    scope="local",
    path=repo_path,
)

Get started

Model APIs

Agent Sandbox

GPUs

Observability

Resources

Autenticación e identidad

Credenciales en línea

Autenticarse una vez con el helper de credenciales de Git

Mantener las credenciales en la URL remota

Configurar la identidad de commit

Clonar repositorios

Comprobar el estado del repositorio y las ramas

Crear, cambiar y eliminar ramas

Preparar y confirmar cambios

Pull y push

Administrar remotos

Configuración de Git

​Autenticación e identidad

​Credenciales en línea

​Autenticarse una vez con el helper de credenciales de Git

​Mantener las credenciales en la URL remota

​Configurar la identidad de commit

​Clonar repositorios

​Comprobar el estado del repositorio y las ramas

​Crear, cambiar y eliminar ramas

​Preparar y confirmar cambios

​Pull y push

​Administrar remotos

​Configuración de Git

Autenticación e identidad

Credenciales en línea

Autenticarse una vez con el helper de credenciales de Git

Mantener las credenciales en la URL remota

Configurar la identidad de commit

Clonar repositorios

Comprobar el estado del repositorio y las ramas

Crear, cambiar y eliminar ramas

Preparar y confirmar cambios

Pull y push

Administrar remotos

Configuración de Git