Go Sandbox for AI Agents

# Sandbox a Go AI agent with read-write to the project
nono run --allow-cwd -- go run .

# Use the go-dev profile (includes go_runtime security group)
nono run --profile go-dev -- go run .

# Restrict network to LLM API endpoints only
nono run --allow-cwd --network-profile minimal -- ./my-agent

# Inject credentials from keychain (real keys never enter the sandbox)
nono run --allow-cwd --credential openai -- ./my-agent

# Sandbox go build and go test
nono run --profile go-dev --allow-cwd -- go build ./...
nono run --profile go-dev --allow-cwd -- go test ./...

{
  "meta": {
    "name": "go-agent",
    "version": "1.0.0",
    "description": "Go AI agent with controlled access"
  },
  "security": {
    "groups": ["go_runtime"]
  },
  "filesystem": {
    "allow": ["$HOME/.cache/go-build"],
    "read_file": ["$HOME/.gitconfig"]
  },
  "network": {
    "network_profile": "minimal"
  },
  "workdir": { "access": "readwrite" },
  "interactive": false
}

package main

import (
	"errors"
	"fmt"
	"log"
	"github.com/always-further/nono-go"
)

func main() {
	// 1. Build a capability set
	caps := nono.New()
	defer caps.Close()

	if err := caps.AllowPath("/home/user/data", nono.AccessRead); err != nil {
		log.Fatal(err)
	}
	if err := caps.AllowPath("/tmp", nono.AccessReadWrite); err != nil {
		log.Fatal(err)
	}
	if err := caps.SetNetworkMode(nono.NetworkBlocked); err != nil {
		log.Fatal(err)
	}

	// 2. Query permissions before applying (dry-run)
	qc, err := nono.NewQueryContext(caps)
	if err != nil {
		log.Fatal(err)
	}
	defer qc.Close()

	result, err := qc.QueryPath("/home/user/data/file.txt", nono.AccessRead)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(result.Status) // nono.QueryAllowed

	// 3. Apply sandbox (irreversible)
	if err := nono.Apply(caps); err != nil {
		log.Fatal(err)
	}

	// 4. Error handling with sentinel accessors
	err = caps.AllowPath("/nonexistent", nono.AccessRead)
	if errors.Is(err, nono.ErrPathNotFound()) {
		fmt.Println("path does not exist")
	}
}

package main

import (
	"fmt"
	"log"
	"github.com/always-further/nono-go"
)

func main() {
	caps := nono.New()
	if err := caps.AllowPath("/data", nono.AccessReadWrite); err != nil {
		log.Fatal(err)
	}
	if err := caps.SetNetworkMode(nono.NetworkBlocked); err != nil {
		log.Fatal(err)
	}

	// Serialize to JSON
	state, err := nono.StateFromCaps(caps)
	if err != nil {
		log.Fatal(err)
	}
	defer state.Close()

	jsonStr, err := state.ToJSON()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(jsonStr)

	// Restore from JSON
	restored, err := nono.StateFromJSON(jsonStr)
	if err != nil {
		log.Fatal(err)
	}
	defer restored.Close()

	caps2, err := restored.ToCaps()
	if err != nil {
		log.Fatal(err)
	}
	defer caps2.Close()
}