Hanzo Playground

control-plane/
  cmd/playground/              # Unified CLI (server + dev/init)
  cmd/playground-server/       # Standalone server binary
  internal/
    server/                    # HTTP server (Gin), middleware, routing
    handlers/                  # REST/gRPC request handlers
    services/                  # Business logic (workflow, bot registry, DID/VC)
    storage/                   # Data layer (SQLite/BoltDB, PostgreSQL)
    cloud/                     # Cloud provisioning (K8s + Visor)
    mcp/                       # Model Context Protocol integration
    encryption/                # Cryptographic primitives (DID/VC)
  migrations/                  # Goose SQL migrations
  web/client/                  # React/TypeScript admin UI (Vite)
sdk/
  python/                      # Python SDK (FastAPI bot builder)
  go/                          # Go SDK (bot builder + skills)
  typescript/                  # TypeScript SDK
deployments/
  docker/                      # Docker Compose + Dockerfile
  helm/                        # Helm chart
  kubernetes/                  # Raw K8s manifests

cd control-plane
go run ./cmd/playground dev
# Runs at http://localhost:8080, UI at http://localhost:8080/ui/
# Uses SQLite + BoltDB (no PostgreSQL needed)

cd control-plane
export PLAYGROUND_DATABASE_URL="postgres://playground:playground@localhost:5432/playground?sslmode=disable"

# Run migrations
goose -dir ./migrations postgres "$PLAYGROUND_DATABASE_URL" up

# Start server
PLAYGROUND_STORAGE_MODE=postgresql go run ./cmd/playground-server

cd deployments/docker
docker compose up

# Scaffold a new bot
playground init my-bot
cd my-bot

# Edit bot code, then run
playground run

# Python SDK: register "reasoners" (decorated functions become REST endpoints)
from playground import Bot

bot = Bot("my-bot", server="http://localhost:8080")

@bot.reasoner("greet")
async def greet(input):
    return {"message": f"Hello, {input.get('name', 'world')}!"}

bot.run()

import playgroundbot "github.com/hanzoai/playground/sdk/go/bot"

bot, _ := playgroundbot.New(playgroundbot.Config{
    NodeID:        "my-bot",
    PlaygroundURL: "http://localhost:8080",
})
bot.RegisterSkill("greet", func(ctx context.Context, input map[string]any) (any, error) {
    return map[string]any{"message": "hello"}, nil
})
bot.Run(context.Background())

result = await bot.call("other-bot.function", input={"key": "value"})
# Control plane routes request, tracks workflow DAG, injects metrics

# Export audit trail
GET /api/v1/did/workflow/{workflow_id}/vc-chain

# Verify offline
playground verify audit.json

make install             # Install all dependencies
make build               # Build all components
make test                # Run all tests

# Component-specific
cd control-plane && go test ./...
cd sdk/python && pytest
cd sdk/go && go test ./...

# Lint and format
make lint
make fmt
make tidy

PLAYGROUND_PORT=8080                    # HTTP server port
PLAYGROUND_MODE=local                   # local or cloud
PLAYGROUND_STORAGE_MODE=local           # local, postgresql, or cloud
PLAYGROUND_DATABASE_URL=postgres://...  # PostgreSQL connection
PLAYGROUND_UI_ENABLED=true              # Enable web UI
PLAYGROUND_UI_MODE=embedded             # embedded or development
PLAYGROUND_CONFIG_FILE=config.yaml      # Config file path
GIN_MODE=release                        # debug or release
LOG_LEVEL=info                          # debug, info, warn, error