fix: safeguards against orphaned copilot servers

Fixes zbirenbaum#667

Author: AntoineGS

lua/copilot/client/init.lua

@@ -14,13 +14,15 @@ local is_disabled = false
 ---@field config vim.lsp.ClientConfig | nil
 ---@field startup_error string | nil
 ---@field initialized boolean
+---@field client_starting boolean
 local M = {
   augroup = nil,
   id = nil,
   capabilities = nil,
   config = nil,
   startup_error = nil,
   initialized = false,
+  client_starting = false,
 }
 
 ---@param id integer
@@ -141,6 +143,11 @@ function M.ensure_client_started()
     return
   end
 
+  if M.client_starting then
+    logger.trace("client startup already in progress, skipping duplicate")
+    return
+  end
+
   if is_disabled then
     logger.debug("copilot is offline")
     return
@@ -155,9 +162,13 @@ function M.ensure_client_started()
     return
   end
 
+  M.client_starting = true
+
   M.config.root_dir = utils.get_root_dir(config.root_dir)
   local client_id, err = vim.lsp.start(M.config, { attach = false })
 
+  M.client_starting = false
+
   if not client_id then
     logger.error(string.format("error starting LSP client: %s", err))
     return
@@ -208,6 +219,11 @@ function M.setup()
     return
   end
 
+  -- Stop all existing copilot clients to prevent orphan processes
+  for _, existing_client in ipairs(vim.lsp.get_clients({ name = "copilot" })) do
+    existing_client:stop(true)
+  end
+
   is_disabled = false
   M.id = nil
 
@@ -225,6 +241,17 @@ function M.setup()
     desc = "[copilot] (client) buf entered",
   })
 
+  vim.api.nvim_create_autocmd("VimLeavePre", {
+    group = M.augroup,
+    callback = function()
+      local client = vim.lsp.get_client_by_id(M.id)
+      if client then
+        client:stop()
+      end
+    end,
+    desc = "[copilot] (client) stop LSP client on exit",
+  })
+
   vim.api.nvim_create_autocmd("BufFilePost", {
     group = M.augroup,
     callback = function(args)

tests/files/saved_new.txt

@@ -0,0 +1,3 @@
+123
+456
+7

tests/test_client_lifecycle.lua

@@ -0,0 +1,158 @@
+local child_helper = require("tests.child_helper")
+local child = child_helper.new_child_neovim("test_client_lifecycle")
+local u = require("tests.utils")
+local eq = MiniTest.expect.equality
+
+local T = MiniTest.new_set({
+  hooks = {
+    pre_once = function() end,
+    pre_case = function()
+      child.run_pre_case(true)
+      child.lua("c = require('copilot.client')")
+    end,
+    post_once = child.stop,
+  },
+})
+
+T["client lifecycle()"] = MiniTest.new_set()
+
+-- Fix #1: ensure_client_started should have a startup guard to prevent duplicate spawns
+T["client lifecycle()"]["ensure_client_started sets starting guard during startup"] = function()
+  child.configure_copilot()
+
+  -- After initialization, client_starting should be false (startup completed)
+  local client_starting = child.lua("return c.client_starting")
+  eq(client_starting, false)
+end
+
+T["client lifecycle()"]["ensure_client_started with starting guard prevents duplicate calls"] = function()
+  child.configure_copilot()
+
+  -- Simulate the guard being set (as if startup is in progress)
+  child.lua("c.client_starting = true")
+
+  -- Store original client id
+  local original_id = child.lua("return c.id")
+
+  -- Try to start another client - should be blocked by the guard
+  child.lua([[
+    c.id = nil
+    c.ensure_client_started()
+  ]])
+
+  -- id should still be nil because the guard prevented a new start
+  local new_id = child.lua("return c.id")
+  eq(new_id, vim.NIL)
+end
+
+-- Fix #2: setup() should stop existing client before resetting M.id
+T["client lifecycle()"]["setup stops existing client before resetting id"] = function()
+  child.configure_copilot()
+
+  -- Verify client is running
+  local id_before = child.lua("return c.id")
+  assert(id_before ~= vim.NIL, "client should be running")
+
+  -- Track whether the old client was stopped
+  child.lua([[
+    _G.old_client_stopped = false
+    local old_client = vim.lsp.get_client_by_id(c.id)
+    if old_client then
+      local original_stop = old_client.stop
+      old_client.stop = function(self, ...)
+        _G.old_client_stopped = true
+        return original_stop(self, ...)
+      end
+    end
+  ]])
+
+  -- Call setup again (simulates :Copilot disable then :Copilot enable)
+  child.lua("c.setup()")
+  child.lua("vim.wait(500, function() return false end, 10)")
+
+  -- The old client should have been stopped
+  local was_stopped = child.lua("return _G.old_client_stopped")
+  eq(was_stopped, true)
+end
+
+-- Fix #3: VimLeavePre should clean up the LSP client
+T["client lifecycle()"]["setup registers VimLeavePre autocmd"] = function()
+  child.configure_copilot()
+
+  local has_autocmd = child.lua([[
+    local autocmds = vim.api.nvim_get_autocmds({
+      group = "copilot.client",
+      event = "VimLeavePre",
+    })
+    return #autocmds > 0
+  ]])
+
+  eq(has_autocmd, true)
+end
+
+T["client lifecycle()"]["VimLeavePre stops the LSP client"] = function()
+  child.configure_copilot()
+
+  -- Verify client is running
+  local id = child.lua("return c.id")
+  assert(id ~= vim.NIL, "client should be running")
+
+  -- Track whether stop was called
+  child.lua([[
+    _G.client_stopped_on_leave = false
+    local client_obj = vim.lsp.get_client_by_id(c.id)
+    if client_obj then
+      local original_stop = client_obj.stop
+      client_obj.stop = function(self, ...)
+        _G.client_stopped_on_leave = true
+        return original_stop(self, ...)
+      end
+    end
+  ]])
+
+  -- Trigger VimLeavePre
+  child.lua([[
+    vim.api.nvim_exec_autocmds("VimLeavePre", { group = "copilot.client" })
+    vim.wait(200, function() return false end, 10)
+  ]])
+
+  local was_stopped = child.lua("return _G.client_stopped_on_leave")
+  eq(was_stopped, true)
+end
+
+-- Regression: disable/enable cycle should not leak processes
+T["client lifecycle()"]["disable then enable does not leak client processes"] = function()
+  child.configure_copilot()
+
+  local id_before = child.lua("return c.id")
+  assert(id_before ~= vim.NIL, "client should be running")
+
+  -- Disable and re-enable
+  child.lua([[
+    require("copilot.command").disable()
+    vim.wait(200, function() return false end, 10)
+    require("copilot.command").enable()
+  ]])
+
+  -- Wait for the new client to initialize
+  child.lua([[
+    vim.wait(2000, function()
+      return require("copilot.client").initialized
+    end, 10)
+  ]])
+
+  -- There should be exactly 1 active (non-stopped) copilot LSP client
+  local client_count = child.lua([[
+    local count = 0
+    for _, cl in ipairs(vim.lsp.get_clients({ name = "copilot" })) do
+      if not cl:is_stopped() then
+        count = count + 1
+      end
+    end
+    return count
+  ]])
+
+  eq(client_count, 1)
+end
+
+return T