🦥 Sloth Runner - AI-Powered GitOps Task Orchestration Platform¶

task("deploy-web-cluster")
    :description("Deploy complete web cluster with Incus")
    :delegate_to("incus-host-01")
    :command(function()
        -- Create isolated network
        incus.network({
            name = "web-dmz",
            type = "bridge"
        }):set_config({
            ["ipv4.address"] = "10.10.0.1/24"
        }):create()

        -- Deploy 3 web servers in parallel
        goroutine.map({"web-01", "web-02", "web-03"}, function(name)
            incus.instance({
                name = name,
                image = "ubuntu:22.04"
            }):create()
              :start()
              :wait_running()
              :exec("apt install -y nginx")
        end)

        log.info("✅ Web cluster deployed!")
        return true
    end)
    :build()

task("intelligent-deploy")
    :description("Intelligent deployment based on system facts")
    :command(function()
        -- Collect system information
        local info = facts.get_all({ agent = "prod-server-01" })

        log.info("🔍 Analyzing: " .. info.hostname)
        log.info("   Platform: " .. info.platform.os)
        log.info("   Memory: " .. string.format("%.2f GB", 
            info.memory.total / 1024 / 1024 / 1024))

        -- Validate requirements
        if (info.memory.total / 1024 / 1024 / 1024) < 4 then
            error("❌ Need at least 4GB RAM")
        end

        -- Check Docker installation
        local docker = facts.get_package({ 
            agent = "prod-server-01", 
            name = "docker" 
        })

        if not docker.installed then
            log.info("📦 Installing Docker...")
            pkg.install({ packages = {"docker.io"} })
               :delegate_to("prod-server-01")
        end

        -- Conditional deploy based on architecture
        local image_tag = info.platform.architecture == "arm64"
            and "latest-arm64"
            or "latest-amd64"

        log.info("🚀 Deploying: myapp:" .. image_tag)
        return true
    end)
    :build()

-- Package Management
task("setup_web_server", {
    description = "Setup web server on remote host",
    command = function()
        -- Update package database
        pkg.update({ delegate_to = "web-server" })

        -- Install packages
        pkg.install({
            packages = {"nginx", "certbot", "postgresql"},
            delegate_to = "web-server"
        })

        -- Configure systemd service
        systemd.enable({
            service = "nginx",
            delegate_to = "web-server"
        })

        systemd.start({
            service = "nginx",
            delegate_to = "web-server"
        })

        -- Verify installation
        infra_test.service_is_running({
            name = "nginx",
            delegate_to = "web-server"
        })

        infra_test.port_is_listening({
            port = 80,
            delegate_to = "web-server"
        })

        return true, "Web server configured successfully"
    end
})

-- Complete GitOps workflow in clean, readable syntax
local clone_task = task("clone_infrastructure")
    :description("Clone Terraform infrastructure repository")
    :workdir("/tmp/infrastructure")
    :command(function(this, params)
        local git = require("git")

        log.info("📡 Cloning infrastructure repository...")
        local repository = git.clone(
            values.git.repository_url,
            this.workdir.get()
        )

        return true, "Repository cloned successfully", {
            repository_url = values.git.repository_url,
            clone_destination = this.workdir.get()
        }
    end)
    :timeout("5m")
    :retries(3, "exponential")
    :build()

local deploy_task = task("deploy_terraform")
    :description("Deploy infrastructure using Terraform")
    :command(function(this, params)
        local terraform = require("terraform")

        -- Terraform init runs automatically
        local client = terraform.init(this.workdir:get())

        -- Load configuration from values.yaml
        local tfvars = client:create_tfvars("terraform.tfvars", {
            environment = values.terraform.environment,
            region = values.terraform.region,
            instance_type = values.terraform.instance_type
        })

        -- Plan and apply infrastructure
        local plan_result = client:plan({ var_file = tfvars.filename })
        if plan_result.success then
            return client:apply({ 
                var_file = tfvars.filename,
                auto_approve = true 
            })
        end

        return false, "Terraform plan failed"
    end)
    :timeout("15m")
    :build()

-- Define the complete GitOps workflow
workflow.define("infrastructure_deployment")
    :description("Complete GitOps: Clone + Plan + Deploy")
    :version("1.0.0")
    :tasks({ clone_task, deploy_task })
    :config({
        timeout = "20m",
        max_parallel_tasks = 1
    })
    :on_complete(function(success, results)
        if success then
            log.info("🎉 Infrastructure deployed successfully!")
        end
    end)

-- Git operations with automatic credential handling
local git = require("git")
local repo = git.clone("https://github.com/company/infrastructure", "/tmp/infra")
git.checkout(repo, "production")
git.pull(repo, "origin", "production")

-- Terraform lifecycle management
local terraform = require("terraform")
local client = terraform.init("/tmp/infra/terraform/")  -- Runs 'terraform init'
local plan = client:plan({ var_file = "production.tfvars" })
local apply = client:apply({ auto_approve = true })

-- Values-driven configuration
local config = {
    environment = values.terraform.environment or "production",
    region = values.terraform.region or "us-west-2",
    instance_count = values.terraform.instance_count or 3
}

-- Load configuration from values.yaml
local terraform_config = {
    environment = values.terraform.environment,
    region = values.terraform.region,
    instance_type = values.terraform.instance_type
}

local deploy_task = task("deploy_multi_server")
    :description("Deploy to 10 servers in parallel - 10x faster!")
    :command(function(this, params)
        local goroutine = require("goroutine")

        -- Lista de servidores para deploy
        local servers = {
            "web-01", "web-02", "web-03", "api-01", "api-02",
            "api-03", "db-01", "db-02", "cache-01", "cache-02"
        }

        log.info("🚀 Starting parallel deployment to " .. #servers .. " servers...")

        -- Criar handles assíncronos para cada servidor
        local handles = {}
        for _, server in ipairs(servers) do
            local handle = goroutine.async(function()
                log.info("📦 Deploying to " .. server)

                -- Simula deploy (upload, install, restart, health check)
                goroutine.sleep(500)

                return server, "deployed", os.date("%H:%M:%S")
            end)

            table.insert(handles, handle)
        end

        -- Aguardar TODOS os deploys completarem
        local results = goroutine.await_all(handles)

        -- Processar resultados
        log.info("📊 All " .. #results .. " servers deployed successfully!")

        return true, "Parallel deployment completed in ~3 seconds!"
    end)
    :timeout("2m")
    :build()

workflow.define("parallel_deployment")
    :description("Deploy to multiple servers in parallel")
    :tasks({ deploy_task })

-- AI-powered workflow optimization
local ai = require("ai")
local result = ai.openai.complete("Generate Docker build script")
local decision = ai.decide({
    cpu_usage = metrics.cpu,
    memory_usage = metrics.memory
})

-- Advanced state operations
local state = require("state")
state.lock("deploy-resource", 30)  -- 30 second lock
state.set("config", data, 3600)    -- 1 hour TTL
state.atomic_increment("build-count")

local deploy_task = task("deploy")
    :command(function(params, deps)
        -- Deploy application
        local result = exec.run("kubectl apply -f deployment.yaml")

        -- Export important outputs to stack
        runner.Export({
            app_url = "https://myapp.example.com",
            version = "1.2.3",
            environment = "production",
            deployed_at = os.date(),
            health_endpoint = "https://myapp.example.com/health"
        })

        return true, result.stdout, { status = "deployed" }
    end)
    :build()

workflow.define("production_deployment", {
    tasks = { deploy_task }
})

local monitoring = require("monitoring")
local state = require("state")

-- Production deployment with comprehensive monitoring
local deploy_task = task("production_deployment")
    :command(function(params, deps)
        -- Track deployment metrics
        monitoring.counter("deployments_started", 1)

        -- Use state for coordination
        local deploy_id = state.increment("deployment_counter", 1)
        state.set("current_deployment", deploy_id)

        -- Execute deployment
        local result = exec.run("kubectl apply -f production.yaml")

        if result.success then
            monitoring.gauge("deployment_status", 1)
            state.set("last_successful_deploy", os.time())
            log.info("✅ Deployment " .. deploy_id .. " completed successfully")
        else
            monitoring.gauge("deployment_status", 0)
            monitoring.counter("deployments_failed", 1)
            log.error("❌ Deployment " .. deploy_id .. " failed: " .. result.stderr)
        end

        return result
    end)
    :build()

local distributed = require("distributed")

-- Execute tasks across multiple agents
workflow.define("distributed_pipeline", {
    tasks = {
        task("build_frontend")
            :agent("build-agent-1")
            :command("npm run build")
            :build(),

        task("build_backend")
            :agent("build-agent-2")
            :command("go build -o app ./cmd/server")
            :build(),

        task("run_tests")
            :agent("test-agent")
            :depends_on({"build_frontend", "build_backend"})
            :command("npm test && go test ./...")
            :build(),

        task("deploy")
            :agent("deploy-agent")
            :depends_on({"run_tests"})
            :command("./deploy.sh production")
            :build()
    }
})

local state = require("state")

-- Complex state operations with locking
local update_config = task("update_configuration")
    :command(function(params, deps)
        -- Critical section with automatic locking
        return state.with_lock("config_update", function()
            local current_version = state.get("config_version") or 0
            local new_version = current_version + 1

            -- Atomic configuration update
            local success = state.compare_and_swap("config_version", current_version, new_version)

            if success then
                state.set("config_data", params.new_config)
                state.set("config_updated_at", os.time())
                log.info("Configuration updated to version " .. new_version)
                return { version = new_version, success = true }
            else
                log.error("Configuration update failed - version mismatch")
                return { success = false, error = "version_mismatch" }
            end
        end)
    end)
    :build()

local git = require("git")
local docker = require("docker")
local kubernetes = require("kubernetes")

-- Complete CI/CD pipeline
workflow.define("gitops_pipeline", {
    on_git_push = true,

    tasks = {
        task("checkout_code")
            :command(function()
                return git.clone(params.repository, "/tmp/build")
            end)
            :build(),

        task("run_tests")
            :depends_on({"checkout_code"})
            :command("cd /tmp/build && npm test")
            :retry_count(3)
            :build(),

        task("build_image")
            :depends_on({"run_tests"})
            :command(function()
                return docker.build({
                    path = "/tmp/build",
                    tag = "myapp:" .. params.git_sha,
                    push = true
                })
            end)
            :build(),

        task("deploy_staging")
            :depends_on({"build_image"})
            :command(function()
                return kubernetes.apply_manifest({
                    file = "/tmp/build/k8s/staging.yaml",
                    namespace = "staging",
                    image = "myapp:" .. params.git_sha
                })
            end)
            :build(),

        task("integration_tests")
            :depends_on({"deploy_staging"})
            :command("./run-integration-tests.sh staging")
            :build(),

        task("deploy_production")
            :depends_on({"integration_tests"})
            :condition(function() return params.branch == "main" end)
            :command(function()
                return kubernetes.apply_manifest({
                    file = "/tmp/build/k8s/production.yaml",
                    namespace = "production",
                    image = "myapp:" .. params.git_sha
                })
            end)
            :build()
    }
})

task("hello")
  :description("My first Sloth Runner task")
  :command(function() 
    log.info("🦥 Hello from Sloth Runner!")
    return true 
  end)
  :build()

workflow.define("greeting")
  :description("Simple greeting workflow")
  :tasks({"hello"})