Intégration Git

Novita Sandbox expose des helpers sandbox.git pour les workflows de dépôt courants, tels que le clonage, la création de branches, les commits, le pull, le push, la gestion des remotes et la configuration de Git.

Authentification et identité

Identifiants en ligne

Pour les dépôts HTTPS privés, transmettez à la fois un nom d’utilisateur et un mot de passe/token directement dans des opérations telles que 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"),
)

S’authentifier une seule fois avec le helper d’identifiants Git

Vous pouvez utiliser dangerouslyAuthenticate() en JavaScript ou dangerously_authenticate() en Python pour stocker les identifiants dans le helper d’identifiants de la sandbox.

Les identifiants sont écrits sur le disque à l’intérieur de la sandbox et peuvent être lus par tout ce qui dispose d’un accès à la sandbox.

Les identifiants peuvent être stockés pour GitHub par défaut ou pour un hôte HTTPS personnalisé.

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

Conserver les identifiants dans l’URL du remote

Par défaut, les identifiants sont supprimés de l’URL du remote après le clonage. Pour les conserver dans .git/config, définissez dangerouslyStoreCredentials: true (JS) ou dangerously_store_credentials=True (Python).

Les identifiants conservés dans une URL de remote restent dans la configuration du dépôt et sont lisibles par les processus de la 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,
)

Configurer l’identité de commit

Vous pouvez utiliser configureUser (JS) ou configure_user (Python) pour définir les détails de l’auteur des commits globalement ou localement pour un dépôt.

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

Cloner des dépôts

Les options de clonage prises en charge incluent le chemin de destination, la sélection de branche, la profondeur, le nom d’utilisateur, le mot de passe et le comportement de stockage des identifiants.

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)

Vérifier l’état du dépôt et les branches

Vous pouvez utiliser status() pour inspecter la branche actuelle, les décomptes d’avance/behind et l’état des fichiers. Vous pouvez utiliser branches() pour obtenir la liste des branches et la branche actuelle.

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)

Créer, changer et supprimer des 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,
)

Préparer et committer les modifications

Vous pouvez utiliser add pour préparer toutes les modifications ou les fichiers sélectionnés. Vous pouvez utiliser commit pour créer des commits. Les options incluent un nom d’auteur personnalisé, une adresse e-mail d’auteur et les commits vides.

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

push et pull peuvent utiliser l’upstream configuré par défaut. Vous pouvez également spécifier le remote, la branche et la configuration de l’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",
)

Gérer les remotes

Vous pouvez utiliser remoteAdd (JS) ou remote_add (Python) pour ajouter des remotes, éventuellement lancer un fetch après l’ajout, ou remplacer un remote existant.

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

Configuration Git

Vous pouvez utiliser setConfig / set_config et getConfig / get_config pour gérer les paramètres Git globalement ou par dépôt.

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

Authentification et identité

Identifiants en ligne

S’authentifier une seule fois avec le helper d’identifiants Git

Conserver les identifiants dans l’URL du remote

Configurer l’identité de commit

Cloner des dépôts

Vérifier l’état du dépôt et les branches

Créer, changer et supprimer des branches

Préparer et committer les modifications

Pull et push

Gérer les remotes

Configuration Git

​Authentification et identité

​Identifiants en ligne

​S’authentifier une seule fois avec le helper d’identifiants Git

​Conserver les identifiants dans l’URL du remote

​Configurer l’identité de commit

​Cloner des dépôts

​Vérifier l’état du dépôt et les branches

​Créer, changer et supprimer des branches

​Préparer et committer les modifications

​Pull et push

​Gérer les remotes

​Configuration Git

Authentification et identité

Identifiants en ligne

S’authentifier une seule fois avec le helper d’identifiants Git

Conserver les identifiants dans l’URL du remote

Configurer l’identité de commit

Cloner des dépôts

Vérifier l’état du dépôt et les branches

Créer, changer et supprimer des branches

Préparer et committer les modifications

Pull et push

Gérer les remotes

Configuration Git