devcontainer will not start when I open a go file locally in my project file

[alfrye]

Description
I have a go project where I am trying to replicate my workflow from vscode. The project has .devcontainer folder in the project root.
I have all my go tooling being installed in the Dockerfile that is referenced in my devcontainer.json file.

I am trying to configure my local nvim in a way that when I open *.go file locally and the devcontainer cli will start the container and I will have lsp integration.

I am using nvim nightly with the nvim.lsp-config plugin installed. here is my lspconfig.lua file config

Expected Behavior
When I open a go file in my project the plugin will call devcontainer cli to start the devcontainer with lsp support.

Actual Behavior
When I open a project file nothing seems to happen.

I have seen the devcontainer get created when I open a lua file in my project folder, however I think this works because my locak neovim configuration has the lua language server installed locally.

I am not sure what I am missing with my setup

[jedrzejboczar]

Could you please enable trace logs, e.g.

require('devcontainers').setup { log = { level = 'trace' } }

and then check the log file (there is a command :DevcontainersLog).

If you can please provide the log file, otherwise you can search for logs with "on_new_config" to see if the function is being invoked.

---

The new Neovim vim.lsp.config API is not compatible with nvim-lspconfig's on_new_config. The nvim-lspconfig approach should work with old version of Neovim and nvim-lspconfig, but I can't recall if it was possible to use Neovim nightly and nvim-lspconfig or if something changed that much that they are completely incompatible.

Anyway, you may want to transition to the new vim.lsp.config API if you are using Neovim nightly, as the old API will become harder to maintain as everything is transitioning to the new API (as devcontainers.nvim did).

If you don't feel like transitioning now, then we can investigate the logs as I described above.

[alfrye]

Thanks for the response,

Here are the logs from running the :DevcontainersLog command. This is with my current setup and only installing the language servers in the devcontainer via my Dockerfile. Also, if I run devcontainer exec for the devcontainer cli, I was able to verify that the lua-language-server is located in my path.

[2025-08-24 08:58:24.134898|ERROR] cli: exec failed for /home/alanfrye/code/SSE: stderr="" stdout="OCI runtime exec failed: exec failed: unable to start container process: exec: "lua-language-server": executable file not found in $PATH: unknown " signal=0 [2025-08-24 08:58:24.134926|ERROR] Could not start lua_ls LSP in devcontainer, falling back to local: /home/alanfrye/code/SSE

I am going to transition my setup to the new vim.lsp setup to see if that works better

[alfrye]

Updated config to no longer use the nvim-lsp-config plugin and use the vim.lsp that is built into Neovim.

I created a folder called .config/lua/lsp that contains the language server-specific configuration(one for gopls and one for lua_ls) lsp config
under the config/lua/config I added a file lsp.lua that contains the following
`vim.lsp.enable({
"gopls",
-- "lua_ls",
})
vim.diagnostic.config({
virtual_lines = true,
underline = true,
update_in_insert = false,
severity_sort = true,
float = {
border = "rounded",
source = true,
}
})

-- vim.lsp.config('lua_ls', { cmd = require('devcontainers').lsp_cmd(vim.lsp.config.lua_ls.cmd) })
-- vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd(vim.lsp.config.gopls.cmd) })

vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd({ 'gopls' }) })`

When open a .go file I see the following error:

../nvim/lazy/devcontainers.nvim/lua/devcontainers/init.lua:96: config.root_dir: expected At this point config.root_dir should have already been resolved, got nil

[jedrzejboczar]

Here are the logs from running the :DevcontainersLog command. This is with my current setup and only installing the language servers in the devcontainer via my Dockerfile. Also, if I run devcontainer exec for the devcontainer cli, I was able to verify that the lua-language-server is located in my path.

That's strange, it looks like devcontainers.nvim is trying to start the lsp using devcontainers exec and lua-language-server is not in PATH, yet you say that if you run devcontainers exec lua-language-server from command line it works? Could you check what command exactly is being run? Unfortunately there is no log for this in the code, you would have change M.exec in cli.lua to something like:

function M.exec(workspace_dir, cmd, opts)
    local cmd = M.cmd(workspace_dir, 'exec', unpack(cmd))
    log.trace('exec %s', utils.lazy_inspect(cmd))
    local result = utils.system(cmd, opts)
    if result.code ~= 0 then
        log.exception('exec failed for %s: stderr="%s" stdout="%s" signal=%s', workspace_dir, result.stderr, result.stdout, result.signal)
    end
    return { stdout = result.stdout, stderr = result.stderr }
end

Maybe the invoked command is different?

---

../nvim/lazy/devcontainers.nvim/lua/devcontainers/init.lua:96: config.root_dir: expected At this point config.root_dir should have already been resolved, got nil

Could you show what is the output of :lua vim.print(vim.lsp.config.gopls)? And maybe provide the devcontainer.nvim trace logs? I am not sure why config.root_dir is nil at that point, it should have already been resolved. I have tested very similar setup with clangd and didn't have this problem. Maybe this is related to the fact that gopls in nvim-lspconfig uses this complex function for root_dir?

[alfrye]

I think the reason I was getting the config.root_dir error was due this getting loaded in the wrong order. I am loading plugins using lazy_nvim and in my main init.lua was loading the config folder after lazy_vim loaded. my lua/config folder contains a lsp.lua file that has the following code.

`
vim.lsp.enable({
"gopls",
-- "lua_ls",
})

vim.diagnostic.config({
virtual_lines = true,
underline = true,
update_in_insert = false,
severity_sort = true,
float = {
border = "rounded",
source = true,
}
})

-- vim.lsp.config('lua_ls', { cmd = require('devcontainers').lsp_cmd(vim.lsp.config.lua_ls.cmd) })

-- vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd(vim.lsp.config.gopls.cmd) })

vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd({ 'gopls' }) })`

Which I need to load after my plugins directory is loaded that container this plugin.
The plugins folder is load using the following code snippet
`require("lazy").setup("plugins")

If I add the following after the call to load the plugins folder
require('config.lsp') I get the error that config.root_dir is nil.
../nvim/lazy/devcontainers.nvim/lua/devcontainers/init.lua:96: config.root_dir: expected At this point config.root_dir should have already been resolved, got nil

After getting this error, I ran ':lua vim.print(vim.lsp.config.gopls)' and the results is:

{
cmd = <function 1>,
name = "gopls"
}

Question Why should the file be located and loaded to enable the lsp configuration now that I am using nvim's native lsp features

[jedrzejboczar]

Ok, I think I found the issue. It is related to the order in which vim.lsp.config merges configurations from nvim-lspconfig and the onces that you define in your config.

So ideally we want to get the config from nvim-lspconfig/lsp/gopls.lua with just the cmd field replaced. But if you make the following lsp/gopls.lua in your nvim config:

return {
    cmd = require('devcontainers').lsp_cmd({ 'gopls' }),
}

or add vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd({ 'gopls' }) }) in your config, then this seems to be overwritten by nvim-lspconfig/lsp/gopls.lua.

I am not entirely sure what is the official way to solve this. What I tested was to use the following:

vim.schedule(function ()
    vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd({ 'gopls' }) })
end)
vim.lsp.enable({'gopls'})

This way my cmd overwritten the one from nvim-lspconfig while keeping the rest of the config.

It should also work if you make sure that devcontainers.nvim is loaded after nvim-lspconfig and only then use it, e.g. with lazy.nvim

{
    'jedrzejboczar/devcontainers.nvim',
    dependencies = 'neovim/nvim-lspconfig',
    config = function(_, opts)
        local devcontainers = require('devcontainers')
        devcontainers.setup(opts)
        vim.lsp.config('gopls', { cmd = require('devcontainers').lsp_cmd({ 'gopls' }) })
    end
}

Another solution would be to remove nvim-lspconfig from your plugins and just copy-paste the configs from nvim-lspconfig into your config (as lsp/<server>.lua files), then you can just replace the cmd however you want.

[alfrye]

Thanks for the response. I was able to get it working with the following config, but I had to add some extra helper functions for getting the devcontainer to set the workspace folder properly. Here is my current setup, but I will also try your suggestions

devcontainers.lua:
`return {
"jedrzejboczar/devcontainers.nvim",
dependencies = { "neovim/nvim-lspconfig" },
opts = {
-- optional, in case you want to override workspace_folder mapping
-- workspace_folder = function(local_ws)
-- return "/workspaces/" .. vim.fn.fnamemodify(local_ws, ":t")
-- end,
},
config = function(_, opts)
require("devcontainers").setup(opts)

-- Optional: autostart a container when opening Go projects
local aug = vim.api.nvim_create_augroup("DevcontainersAutoUp", { clear = true })
vim.api.nvim_create_autocmd({ "BufReadPre", "BufNewFile" }, {
  group = aug,
  pattern = { "*.go", "go.mod", "go.sum" },
  callback = function(args)
    local util = require("lspconfig.util")
    local root = util.root_pattern(".devcontainer", "devcontainer.json", ".git")(args.file)
    if root then vim.cmd("silent! DevcontainersUp") end
  end,
})

end,
}`

lsp.lua
`return {
"neovim/nvim-lspconfig",
dependencies = {
"williamboman/mason.nvim",
"williamboman/mason-lspconfig.nvim",
},
config = function()
local lspconfig = require("lspconfig")

-- Capabilities (extend for nvim-cmp if installed)
local capabilities = vim.lsp.protocol.make_client_capabilities()
local ok_cmp, cmp_nvim_lsp = pcall(require, "cmp_nvim_lsp")
if ok_cmp then
  capabilities = cmp_nvim_lsp.default_capabilities(capabilities)
end

-- on_attach (keymaps etc.)
local on_attach = function(client, bufnr)
  local bufmap = function(mode, lhs, rhs, desc)
    vim.keymap.set(mode, lhs, rhs, { buffer = bufnr, desc = desc })
  end

  bufmap("n", "gd", vim.lsp.buf.definition, "Goto Definition")
  bufmap("n", "K", vim.lsp.buf.hover, "Hover Documentation")
  bufmap("n", "gi", vim.lsp.buf.implementation, "Goto Implementation")
  bufmap("n", "<leader>rn", vim.lsp.buf.rename, "Rename Symbol")
  bufmap("n", "<leader>ca", vim.lsp.buf.code_action, "Code Action")
  bufmap("n", "gr", vim.lsp.buf.references, "Goto References")
  bufmap("n", "<leader>f", function()
    vim.lsp.buf.format({ async = true })
  end, "Format Buffer")
end

-- Host → container path translation
local function container_workspace(host_path)
  return host_path:gsub("^/home/alanfrye/code", "/workspaces")
end

-------------------------------------------------------------------------
-- gopls (runs inside devcontainer)
-------------------------------------------------------------------------
lspconfig.gopls.setup({
  cmd = {
    "devcontainer",
    "exec",
    "--workspace-folder",
    vim.loop.cwd(),
    "gopls",
  },
  capabilities = capabilities,
  on_attach = on_attach,
  filetypes = { "go", "gomod", "gowork", "gotmpl" },
  root_dir = lspconfig.util.root_pattern("go.work", "go.mod", ".git"),

  before_init = function(params)
    if params and params.rootUri then
      local host_path = vim.uri_to_fname(params.rootUri)
      local container_path = container_workspace(host_path)
      params.rootUri = vim.uri_from_fname(container_path)
      params.workspaceFolders = {
        { uri = params.rootUri, name = "workspace" },
      }
    end
  end,

      vim.diagnostic.config({
    virtual_text = {
        -- Set to true to enable virtual text for diagnostics
        -- Set to false to disable it
        enabled = true,
        -- Optional: Customize the prefix character for virtual text
        prefix = '●', -- Example: '■', '▎', 'x'
        -- Optional: Show the source of the diagnostic (e.g., language server name)
        -- "always" or "if_many"
        source = "always",
    },
    underline = true,
    virtual_lines = true,
    -- Optional: Sort diagnostics by severity for signs and virtual text
    severity_sort = true,
    -- Optional: Configure floating window behavior for diagnostics
    float = {
        source = "always",
        border = "rounded",
    },
}),
  vim.lsp.buf.code_action({
only = {"quickfix"},

})
})

-------------------------------------------------------------------------
-- Other language servers (run locally, not in container)
-------------------------------------------------------------------------

-- Lua
lspconfig.lua_ls.setup({
  capabilities = capabilities,
  on_attach = on_attach,
  settings = {
    Lua = {
      diagnostics = { globals = { "vim" } },
    },
  },
})

-- Bash
lspconfig.bashls.setup({
  capabilities = capabilities,
  on_attach = on_attach,
})

-- (Add other servers here as you need them)

end,
}'

I will provide another update after I try the suggestions for your earlier post. I think my solution may be overkill, and I got some help from AI.