Git-integratie

Novita Sandbox biedt sandbox.git-helpers voor veelvoorkomende repository-workflows, zoals klonen, branches maken, commits maken, pullen, pushen, remotes beheren en Git configureren.

Authenticatie en identiteit

Inline referenties

Voor private HTTPS-repositories geef je zowel een gebruikersnaam als wachtwoord/token rechtstreeks door aan bewerkingen zoals push, pull of 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"),
)

Eén keer authenticeren met de Git credential helper

Je kunt dangerouslyAuthenticate() in JavaScript of dangerously_authenticate() in Python gebruiken om referenties op te slaan in de credential helper van de sandbox.

Referenties worden op schijf geschreven in de sandbox en kunnen worden gelezen door alles met toegang tot de sandbox.

Referenties kunnen standaard worden opgeslagen voor GitHub of voor een aangepaste HTTPS-host.

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

Referenties in de remote-URL behouden

Standaard worden referenties na het klonen uit de remote-URL verwijderd. Om ze in .git/config te behouden, stel je dangerouslyStoreCredentials: true (JS) of dangerously_store_credentials=True (Python) in.

Referenties die in een remote-URL worden bewaard, blijven in de repo-configuratie staan en zijn leesbaar door sandboxprocessen.

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

Commitidentiteit configureren

Je kunt configureUser (JS) of configure_user (Python) gebruiken om details van de commitauteur globaal of lokaal voor een repository in te stellen.

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

Repositories klonen

Ondersteunde kloonopties zijn onder andere doelpad, branchselectie, diepte, gebruikersnaam, wachtwoord en gedrag voor het opslaan van referenties.

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)

Repositorystatus en branches controleren

Je kunt status() gebruiken om de huidige branch, ahead/behind-aantallen en bestandsstatus te inspecteren. Je kunt branches() gebruiken om de branchlijst en huidige branch op te halen.

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)

Branches maken, wisselen en verwijderen

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

Wijzigingen stagen en committen

Je kunt add gebruiken om alle wijzigingen of geselecteerde bestanden te stagen. Je kunt commit gebruiken om commits te maken. Opties zijn onder andere een aangepaste auteursnaam, auteurse-mailadres en lege commits.

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

Pullen en pushen

push en pull kunnen standaard de geconfigureerde upstream gebruiken. Je kunt ook remote, branch en upstream-configuratie opgeven.

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

Remotes beheren

Je kunt remoteAdd (JS) of remote_add (Python) gebruiken om remotes toe te voegen, optioneel te fetchen na het toevoegen, of een bestaande remote te overschrijven.

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

Git-configuratie

Je kunt setConfig / set_config en getConfig / get_config gebruiken om Git-instellingen globaal of per repository te beheren.

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

Authenticatie en identiteit

Inline referenties

Eén keer authenticeren met de Git credential helper

Referenties in de remote-URL behouden

Commitidentiteit configureren

Repositories klonen

Repositorystatus en branches controleren

Branches maken, wisselen en verwijderen

Wijzigingen stagen en committen

Pullen en pushen

Remotes beheren

Git-configuratie

​Authenticatie en identiteit

​Inline referenties

​Eén keer authenticeren met de Git credential helper

​Referenties in de remote-URL behouden

​Commitidentiteit configureren

​Repositories klonen

​Repositorystatus en branches controleren

​Branches maken, wisselen en verwijderen

​Wijzigingen stagen en committen

​Pullen en pushen

​Remotes beheren

​Git-configuratie

Authenticatie en identiteit

Inline referenties

Eén keer authenticeren met de Git credential helper

Referenties in de remote-URL behouden

Commitidentiteit configureren

Repositories klonen

Repositorystatus en branches controleren

Branches maken, wisselen en verwijderen

Wijzigingen stagen en committen

Pullen en pushen

Remotes beheren

Git-configuratie