Git Operations

import { Daytona, Image } from '@daytonaio/sdk'

async function main() {
  const daytona = new Daytona()

  //  first, create a sandbox
  const sandbox = await daytona.create(
    {
      image: Image.base('ubuntu:25.10').runCommands(
        'apt-get update && apt-get install -y --no-install-recommends nodejs npm coreutils',
        'curl -fsSL https://deb.nodesource.com/setup_20.x | bash -',
        'apt-get install -y nodejs',
        'npm install -g ts-node typescript typescript-language-server',
      ),
      language: 'typescript',
    },
    {
      onSnapshotCreateLogs: console.log,
    },
  )

  try {
    const projectDir = 'learn-typescript'

    //  clone the repository
    await sandbox.git.clone('https://github.com/panaverse/learn-typescript', projectDir, 'master')

    //  search for the file we want to work on
    const matches = await sandbox.fs.findFiles(projectDir, 'var obj1 = new Base();')
    console.log('Matches:', matches)

    //  start the language server
    const lsp = await sandbox.createLspServer('typescript', projectDir)
    await lsp.start()

    //  notify the language server of the document we want to work on
    await lsp.didOpen(matches[0].file!)

    //  get symbols in the document
    const symbols = await lsp.documentSymbols(matches[0].file!)
    console.log('Symbols:', symbols)

    //  fix the error in the document
    await sandbox.fs.replaceInFiles([matches[0].file!], 'var obj1 = new Base();', 'var obj1 = new E();')

    //  notify the language server of the document change
    await lsp.didClose(matches[0].file!)
    await lsp.didOpen(matches[0].file!)

    //  get completions at a specific position
    const completions = await lsp.completions(matches[0].file!, {
      line: 12,
      character: 18,
    })
    console.log('Completions:', completions)
  } catch (error) {
    console.error('Error creating sandbox:', error)
  } finally {
    //  cleanup
    await daytona.delete(sandbox)
  }
}

main()

package main

import (
	"context"
	"log"
	"time"

	"github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
	"github.com/daytonaio/daytona/libs/sdk-go/pkg/options"
	"github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

func main() {
	client, err := daytona.NewClient()
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)
	}

	ctx := context.Background()

	// Create a sandbox
	log.Println("Creating sandbox...")
	params := types.SnapshotParams{
		SandboxBaseParams: types.SandboxBaseParams{
			Language: types.CodeLanguagePython,
		},
	}

	sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
	if err != nil {
		log.Fatalf("Failed to create sandbox: %v", err)
	}

	log.Printf("✓ Created sandbox: %s (ID: %s)\n", sandbox.Name, sandbox.ID)
	defer func() {
		log.Println("\nCleaning up...")
		if err := sandbox.Delete(ctx); err != nil {
			log.Printf("Failed to delete sandbox: %v", err)
		} else {
			log.Println("✓ Sandbox deleted")
		}
	}()

	// Git operations example
	log.Println("\nGit operations example...")
	repoPath := "/tmp/test-repo"

	// Create directory for repo
	if err := sandbox.FileSystem.CreateFolder(ctx, repoPath); err != nil {
		log.Fatalf("Failed to create repo directory: %v", err)
	}

	// Clone a public repository
	repoURL := "https://github.com/daytonaio/daytona.git"
	log.Printf("Cloning %s...\n", repoURL)
	if err := sandbox.Git.Clone(ctx, repoURL, repoPath); err != nil {
		log.Fatalf("Failed to clone repository: %v", err)
	}
	log.Println("✓ Repository cloned")

	// Get status
	status, err := sandbox.Git.Status(ctx, repoPath)
	if err != nil {
		log.Fatalf("Failed to get git status: %v", err)
	}
	log.Printf("Current branch: %s\n", status.CurrentBranch)

	// List branches
	branches, err := sandbox.Git.Branches(ctx, repoPath)
	if err != nil {
		log.Fatalf("Failed to list branches: %v", err)
	}
	log.Printf("Branches: %v\n", branches)

	log.Println("\n✓ All git operations completed successfully!")
}