Integração com Git

O Novita Sandbox expõe auxiliares sandbox.git para fluxos de trabalho comuns de repositórios, como clonar, criar branches, fazer commits, fazer pull, fazer push, gerenciar remotes e configurar o Git.

Autenticação e identidade

Credenciais inline

Para repositórios HTTPS privados, passe um nome de usuário e uma senha/token diretamente em operações como push, pull ou 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"),
)

Autentique uma vez com o auxiliar de credenciais do Git

Você pode usar dangerouslyAuthenticate() em JavaScript ou dangerously_authenticate() em Python para armazenar credenciais dentro do auxiliar de credenciais do sandbox.

As credenciais são gravadas em disco dentro do sandbox e podem ser lidas por qualquer coisa com acesso ao sandbox.

As credenciais podem ser armazenadas para o GitHub por padrão ou para um 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")

Mantenha as credenciais na URL remota

Por padrão, as credenciais são removidas da URL remota após o clone. Para mantê-las em .git/config, defina dangerouslyStoreCredentials: true (JS) ou dangerously_store_credentials=True (Python).

Credenciais mantidas em uma URL remota permanecem na configuração do repositório e podem ser lidas por processos do 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,
)

Configure a identidade de commit

Você pode usar configureUser (JS) ou configure_user (Python) para definir os detalhes do autor do commit globalmente ou localmente para um repositório.

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,
)

Clone repositórios

As opções de clone compatíveis incluem caminho de destino, seleção de branch, profundidade, nome de usuário, senha e comportamento de armazenamento de credenciais.

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)

Verifique o status do repositório e as branches

Você pode usar status() para inspecionar a branch atual, contagens de ahead/behind e status dos arquivos. Você pode usar branches() para obter a lista de branches e a branch atual.

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)

Crie, alterne e exclua branches

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,
)

Faça stage e commit das alterações

Você pode usar add para fazer stage de todas as alterações ou de arquivos selecionados. Você pode usar commit para criar commits. As opções incluem nome de autor personalizado, e-mail do autor e commits vazios.

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 e push

push e pull podem usar o upstream configurado por padrão. Você também pode especificar remote, branch e configuração de 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",
)

Gerencie remotes

Você pode usar remoteAdd (JS) ou remote_add (Python) para adicionar remotes, opcionalmente fazer fetch após adicionar, ou sobrescrever um remote 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,
)

Configuração do Git

Você pode usar setConfig / set_config e getConfig / get_config para gerenciar configurações do Git globalmente ou por repositório.

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

Autenticação e identidade

Credenciais inline

Autentique uma vez com o auxiliar de credenciais do Git

Mantenha as credenciais na URL remota

Configure a identidade de commit

Clone repositórios

Verifique o status do repositório e as branches

Crie, alterne e exclua branches

Faça stage e commit das alterações

Pull e push

Gerencie remotes

Configuração do Git

​Autenticação e identidade

​Credenciais inline

​Autentique uma vez com o auxiliar de credenciais do Git

​Mantenha as credenciais na URL remota

​Configure a identidade de commit

​Clone repositórios

​Verifique o status do repositório e as branches

​Crie, alterne e exclua branches

​Faça stage e commit das alterações

​Pull e push

​Gerencie remotes

​Configuração do Git

Autenticação e identidade

Credenciais inline

Autentique uma vez com o auxiliar de credenciais do Git

Mantenha as credenciais na URL remota

Configure a identidade de commit

Clone repositórios

Verifique o status do repositório e as branches

Crie, alterne e exclua branches

Faça stage e commit das alterações

Pull e push

Gerencie remotes

Configuração do Git