Runtime Native

O runtime native executa comandos usando o shell padrão do seu sistema. É a opção mais direta e a que você usará com mais frequência durante o desenvolvimento.

Como Funciona

Quando você executa um comando com o runtime native, o Invowk™:

1. Detecta o shell padrão do seu sistema
2. Cria um arquivo de script temporário
3. Executa-o através do shell
4. Transmite a saída de volta para seu terminal

Detecção de Shell

O Invowk detecta automaticamente o melhor shell disponível:

Linux/macOS

1. Usa a variável de ambiente $SHELL se definida
2. Usa bash como fallback se disponível
3. Usa sh como último recurso

Windows

1. Tenta pwsh (PowerShell Core)
2. Usa powershell (Windows PowerShell) como fallback
3. Usa cmd.exe como último recurso

Uso Básico

{
    name: "build"
    implementations: [
        {
            script: "go build ./..."
            runtimes: [{name: "native"}]
            platforms: [{name: "linux"}, {name: "macos"}, {name: "windows"}]
        }
    ]
}

invowk cmd build

Sobrescrevendo o Shell Padrão

Você pode sobrescrever o shell no nível do invowkfile:

default_shell: "/bin/bash"

cmds: [
    // Commands...
]

Isso é útil quando:

• Você precisa de recursos específicos do bash
• Seu script depende de um shell específico
• Você quer comportamento consistente entre máquinas da equipe

Scripts Específicos por Shell

Bash/Zsh

{
    name: "build"
    implementations: [{
        script: """
            #!/bin/bash
            set -euo pipefail  # Bash strict mode
            
            # Bash-specific features
            declare -A config=(
                ["env"]="production"
                ["debug"]="false"
            )
            
            echo "Building for ${config[env]}..."
            """
        runtimes: [{name: "native"}]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

PowerShell

{
    name: "build"
    implementations: [{
        script: """
            $ErrorActionPreference = "Stop"
            
            Write-Host "Building..." -ForegroundColor Green
            dotnet build --configuration Release
            Write-Host "Done!" -ForegroundColor Green
            """
        runtimes: [{name: "native"}]
        platforms: [{name: "windows"}]
    }]
}

cmd.exe (Windows Batch)

{
    name: "build"
    implementations: [{
        script: """
            @echo off
            echo Building...
            msbuild /p:Configuration=Release
            echo Done!
            """
        runtimes: [{name: "native"}]
        platforms: [{name: "windows"}]
    }]
}

Usando Interpretadores

O runtime native suporta interpretadores não-shell como Python, Ruby ou Node.js.

Auto-Detecção pelo Shebang

{
    name: "analyze"
    implementations: [{
        script: """
            #!/usr/bin/env python3
            import sys
            import json

            print(f"Python {sys.version}")
            data = {"status": "ok", "items": [1, 2, 3]}
            print(json.dumps(data, indent=2))
            """
        runtimes: [{name: "native"}]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

Interpretador Explícito

{
    name: "analyze"
    implementations: [{
        script: """
            import sys
            print(f"Hello from Python {sys.version_info.major}!")
            """
        runtimes: [{
            name: "native"
            interpreter: "python3"  // Explicit interpreter
        }]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

Interpretador com Argumentos

{
    name: "script"
    implementations: [{
        script: """
            print("Unbuffered output!")
            """
        runtimes: [{
            name: "native"
            interpreter: "python3 -u"  // With arguments
        }]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

Variáveis de Ambiente

O runtime native tem acesso completo ao seu ambiente:

{
    name: "deploy"
    env: {
        vars: {
            DEPLOY_ENV: "production"
        }
    }
    implementations: [{
        script: """
            echo "Home: $HOME"
            echo "User: $USER"
            echo "Deploy to: $DEPLOY_ENV"
            """
        runtimes: [{name: "native"}]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

Acessando Flags e Argumentos

Flags e argumentos ficam disponíveis como variáveis de ambiente:

{
    name: "greet"
    flags: [
        {name: "loud", type: "bool", default_value: "false"}
    ]
    args: [
        {name: "name", default_value: "World"}
    ]
    implementations: [{
        script: """
            if [ "$INVOWK_FLAG_LOUD" = "true" ]; then
                echo "HELLO, $INVOWK_ARG_NAME!"
            else
                echo "Hello, $INVOWK_ARG_NAME!"
            fi
            """
        runtimes: [{name: "native"}]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

invowk cmd greet Alice --loud
# Output: HELLO, ALICE!

Diretório de Trabalho

Por padrão, scripts rodam no diretório atual. Sobrescreva com workdir:

{
    name: "build frontend"
    workdir: "./frontend"  // Run in frontend subdirectory
    implementations: [{
        script: "npm run build"
        runtimes: [{name: "native"}]
        platforms: [{name: "linux"}, {name: "macos"}, {name: "windows"}]
    }]
}

Dependências

O runtime native valida dependências no seu sistema:

{
    name: "deploy"
    depends_on: {
        tools: [
            {alternatives: ["docker", "podman"]},
            {alternatives: ["kubectl"]}
        ]
        filepaths: [
            {alternatives: ["Dockerfile"]}
        ]
    }
    implementations: [{
        script: "docker build -t myapp . && kubectl apply -f k8s/"
        runtimes: [{name: "native"}]
        platforms: [{name: "linux"}, {name: "macos"}]
    }]
}

Vantagens

• Performance: Sem overhead, execução direta no shell
• Acesso total: Ferramentas do sistema e ambiente disponíveis
• Familiar: Use seu shell preferido e seus recursos
• Interativo: Pode executar comandos interativos

Limitações

• Diferenças de plataforma: Scripts podem se comportar diferente entre SOs
• Dependência do ambiente: Depende de ferramentas instaladas
• Reprodutibilidade: Resultados podem variar entre máquinas

Quando Usar Native

• Desenvolvimento diário: Iteração rápida, ferramentas familiares
• Integração com o sistema: Quando precisa de acesso a recursos do sistema
• Tarefas interativas: Prompts, editores, aplicações TUI
• Performance crítica: Quando overhead de container importa

Próximos Passos

• Runtime Virtual - Para consistência multiplataforma
• Runtime Container - Para builds reprodutíveis