> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Configuração avançada

> Configurações avançadas do Devin Desktop, incluindo suporte a SSH, Dev Containers, WSL, configurações do marketplace de extensões, zonas de diff e acesso a arquivos gitignore para o Cascade.

Todas as configurações avançadas podem ser encontradas em Devin Settings, acessível pelo menu suspenso no canto superior direito → Devin Settings ou pela Paleta de Comandos (Ctrl/⌘+Shift+P) → Open Devin User Settings.

<div id="enabling-cascade-access-to-gitignore-files">
  # Habilitando o acesso do Cascade a arquivos .gitignore
</div>

Para dar ao Cascade acesso a arquivos que correspondem aos padrões definidos no `.gitignore` do seu projeto, vá para Devin Settings e, em seguida, para "Cascade Gitignore Access". Por padrão, ele vem desativado. Para conceder acesso, ative-o clicando no controle.

<div id="agent-diff-zones">
  # Zonas de diff do agente
</div>

Quando um agente edita arquivos, o Devin Desktop exibe **zonas de diff** — regiões destacadas inline no editor que mostram exatamente o que mudou, com controles para aceitar ou rejeitar cada hunk. Todos os agentes usam zonas de diff por padrão.

Você pode desativar as zonas de diff para agentes que não sejam Cascade em Devin Settings → Interface do usuário → **Agent Diff Zones**. Quando desativadas, as edições de agentes que não sejam Cascade são aplicadas diretamente ao arquivo, e a barra de ferramentas mostra um botão simples de fechar em vez de controles de aceitar/rejeitar.

<div id="ssh-support">
  # Suporte a SSH
</div>

O suporte SSH padrão no VSCode é licenciado pela Microsoft, então implementamos o nosso próprio especificamente para o Devin Desktop. Ele exige que você tenha o [OpenSSH](https://www.openssh.com/) instalado, mas, fora isso, tem poucas dependências e deve simplesmente funcionar como você já está acostumado. Você pode acessar o SSH em `Remote-SSH` na Paleta de Comandos ou pelo botão `Open a Remote Window` no canto inferior esquerdo.
Esta extensão funcionou muito bem no nosso desenvolvimento interno, mas há algumas limitações e bugs conhecidos:

* No momento, só oferecemos suporte a conexões SSH com hosts remotos baseados em Linux.

* A extensão padrão da Microsoft "Remote - SSH" (e a extensão [open-remote-ssh](https://github.com/jeanp413/open-remote-ssh)) não vai funcionar — não as instale, pois entram em conflito com o nosso suporte.

* No momento, não temos todos os recursos da extensão SSH da Microsoft. Por enquanto, damos suporte principalmente ao mais importante: conectar-se a um host. Se você tiver solicitações de recursos, avise-nos!

* Para acessar um devcontainer em um host remoto após se conectar via SSH, use a Paleta de Comandos (Ctrl/Cmd+Shift+P) e escolha uma das seguintes opções:

<Frame>
  <img src="https://mintcdn.com/cognitionai/WE51TvKjsiyk1ZHl/desktop/assets/windsurf/ssh-devcontainer-options.png?fit=max&auto=format&n=WE51TvKjsiyk1ZHl&q=85&s=4a7de13e7604b6569cec985d92bfa75d" width="394" height="65" data-path="desktop/assets/windsurf/ssh-devcontainer-options.png" />
</Frame>

* O agent forwarding do SSH vem ativado por padrão e usará a conexão mais recente do Devin Desktop com esse host. Se você estiver tendo problemas com isso, tente recarregar a janela para atualizar a conexão.

* No Windows, você verá algumas janelas `cmd.exe` quando ele solicitar sua senha. Isso é esperado — vamos eliminá-las em breve.

* Se você tiver problemas, primeiro verifique se consegue se conectar ao host remoto usando o `ssh` normal em um terminal. Se o problema persistir, inclua a saída da aba `Output > Remote SSH (Devin)` em qualquer relato de bug!

<div id="dev-containers">
  # Dev Containers
</div>

O Devin Desktop oferece suporte a Development Containers no Mac, Windows e Linux, tanto em fluxos de trabalho locais quanto remotos (via SSH).

Pré-requisitos:

* Local: o Docker deve estar instalado na sua máquina e acessível pelo terminal do Devin Desktop.
* Remoto via SSH: conecte-se a um host remoto usando o Devin Desktop Remote-SSH. O Docker deve estar instalado e acessível no host remoto (a partir do shell remoto). Seu projeto deve incluir um `devcontainer.json` ou uma configuração equivalente.

Comandos disponíveis (em janelas locais e remotas):

1. `Dev Containers: Open Folder in Container`
   * Abre um novo workspace usando um `devcontainer.json` especificado.
2. `Dev Containers: Reopen in Container`
   * Reabre o workspace atual em um novo contêiner definido pelo seu `devcontainer.json`.
3. `Dev Containers: Attach to Running Container`
   * Conecta-se a um contêiner Docker existente e vincula o workspace atual a ele. Se o contêiner não seguir a [especificação de Development Container](https://containers.dev/implementors/spec/), o Devin Desktop tentará detectar, na medida do possível, o usuário remoto e o ambiente.
4. `Dev Containers: Reopen Folder Locally`
   * Quando estiver conectado a um contêiner de desenvolvimento, desconecta e reabre o workspace no sistema de arquivos local.
5. `Dev Containers: Show Devin Desktop Dev Containers Log`
   * Abre a saída de log do Dev Containers para solução de problemas.

Esses comandos estão disponíveis na Paleta de Comandos e também aparecem quando você clica no botão `Open a Remote Window` no canto inferior esquerdo (inclusive quando está conectado a um host remoto via SSH).

Relacionado:

* `Remote Explorer: Focus on Dev Containers (Devin Desktop) View` — abre rapidamente a visualização do Dev Containers.

<div id="known-limitations">
  ### Limitações conhecidas
</div>

No momento, o Devin Desktop não executa [comandos de ciclo de vida da Dev Container Specification](https://containers.dev/implementors/json_reference/#lifecycle-scripts):

* `onCreateCommand`
* `updateContentCommand`
* `postCreateCommand`
* `postStartCommand`
* `postAttachCommand`

Isso se aplica tanto aos comandos de ciclo de vida no nível do contêiner (definidos em `devcontainer.json`) quanto aos comandos de ciclo de vida no nível do recurso (definidos em `devcontainer-feature.json`). A instalação de dotfiles também não é feita.

**O que funciona:**

* Scripts `install.sh` de recursos (são executados no momento do build da imagem)
* `mounts` de recursos (os volumes são anexados em tempo de execução do contêiner)
* Campo `entrypoint` de recursos (é executado a cada inicialização do contêiner)
* Todas as outras operações executadas no momento do build da imagem (Dockerfile, docker-compose, recursos)

<div id="workaround-using-a-feature-entrypoint-for-runtime-setup">
  ### Solução alternativa: Como usar um entrypoint do recurso para configuração em tempo de execução
</div>

Se você estiver criando um recurso de Dev Container que precise executar uma configuração na inicialização do contêiner (por exemplo, para configurar arquivos de um volume montado), use o campo `entrypoint` do recurso em vez de um comando de ciclo de vida. O entrypoint é executado sempre que o contêiner é iniciado, depois que as montagens são anexadas, e é totalmente autocontido — quem usa seu recurso não precisa modificar o `devcontainer.json`.

No seu `devcontainer-feature.json`, declare o entrypoint:

```json theme={null}
{
    "name": "my-feature",
    "id": "my-feature",
    "version": "1.0.0",
    "mounts": [
        { "type": "volume", "source": "my-volume", "target": "/data/my-dir" }
    ],
    "entrypoint": "/usr/local/share/my-feature/entrypoint.sh"
}
```

No seu `install.sh` (executado durante o build da imagem), escreva o script de entrypoint:

```bash theme={null}
#!/usr/bin/env bash
set -e
mkdir -p /usr/local/share/my-feature
cat > /usr/local/share/my-feature/entrypoint.sh << 'EOF'
#!/bin/sh
# Configuração dependente de montagem (executada a cada início do contêiner, volume montado)
if [ -d /data/my-dir ]; then
    mkdir -p /etc/myapp
    cp /data/my-dir/config /etc/myapp/config
fi
exit 0
EOF
chmod +x /usr/local/share/my-feature/entrypoint.sh
```

<Note>
  O script de entrypoint deve fazer sua configuração inicial e encerrar normalmente. Não termine-o com `exec "$@"` — o próprio wrapper de entrypoint da CLI cuida de passar o controle para o comando do contêiner. Mantenha o script enxuto, já que ele é executado de forma síncrona antes de a IDE se conectar.
</Note>

<div id="wsl-beta">
  # WSL (Beta)
</div>

A partir da versão 1.1.0, o Devin Desktop oferece suporte beta ao Windows Subsystem for Linux. Você já deve ter o WSL instalado e configurado no seu computador com Windows.

Você pode acessar o WSL clicando no botão `Open a Remote Window` no canto inferior esquerdo ou em `Remote-WSL` na Paleta de Comandos.

<div id="extension-marketplace">
  # Marketplace de extensões
</div>

Você pode alterar o marketplace usado para baixar extensões. Para fazer isso, acesse `Devin Settings` e altere as configurações de URL do marketplace na seção `General`.

<Frame>
  <img src="https://mintcdn.com/cognitionai/WE51TvKjsiyk1ZHl/desktop/assets/windsurf/marketplace.png?fit=max&auto=format&n=WE51TvKjsiyk1ZHl&q=85&s=9815a3e8bfc880187c2fc01126c8264b" width="3420" height="2130" data-path="desktop/assets/windsurf/marketplace.png" />
</Frame>

<div id="devin-desktop-plugins">
  ## Plugins do Devin Desktop
</div>

<AccordionGroup>
  <Accordion title="Devin Pyright">
    Pesquise por "Devin Pyright" ou cole `@id:codeium.windsurfPyright` na barra de pesquisa de extensões.
  </Accordion>
</AccordionGroup>