neovim/runtime/lua/vim/_core/server.lua

-- For "--listen" and related functionality.

local M = {}

--- Called by builtin serverlist(). Returns the combined server list (own + peers).
---
---@class vim.ServerInfo
---@field addr string Server address (socket path, named pipe, or TCP host:port).
---@field pid integer PID of the Nvim process.
---@field own boolean True if this server belongs to the current Nvim instance.
---@field active integer Timestamp of last user activity.

--- @param opts? table Options:
---              - opts.peer (boolean): If true, also discover peer servers.
---              - opts.info (boolean): If true, return a list of |vim.ServerInfo| dicts
---                instead of a list of addresses. Implies peer=true.
--- @param addrs string[] Internal ("own") addresses, from server_address_list.
--- @return string[]|vim.ServerInfo[]
function M.serverlist(opts, addrs)
  if type(opts) ~= 'table' then
    return addrs
  end

  local want_info = opts.info == true
  if opts.peer ~= true and not want_info then
    return addrs
  end

  local seen = {} ---@type table<string, true>
  for _, a in ipairs(addrs) do
    seen[a] = true
  end

  local peers ---@type string[]|vim.ServerInfo[]
  if want_info then
    local self_pid = vim.fn.getpid()
    local self_active = vim.v.useractive
    peers = vim.tbl_map(function(addr) ---@param addr vim.ServerInfo
      return {
        addr = addr,
        pid = self_pid,
        own = true,
        active = self_active,
      }
    end, addrs)
  else
    peers = addrs
  end

  -- Discover peer servers in stdpath("run").
  -- TODO: track TCP servers, somehow.
  -- TODO: support Windows named pipes.
  local root = vim.fs.normalize(vim.fn.stdpath('run') .. '/..')
  local socket_paths = vim.fs.find(function(name, _)
    return name:match('nvim.*')
  end, { path = root, type = 'socket', limit = math.huge })

  for _, socket in ipairs(socket_paths) do
    if not seen[socket] then
      local ok, chan = pcall(vim.fn.sockconnect, 'pipe', socket, { rpc = true })
      if ok and chan and chan > 0 then
        -- Check that the server is responding
        -- TODO: do we need a timeout or error handling here?
        local ok_rpc, peer_info = pcall(
          vim.fn.rpcrequest,
          chan,
          'nvim_exec_lua',
          [[return { pid = vim.fn.getpid(), active = vim.v.useractive, }]],
          {}
        )

        if ok_rpc and type(peer_info) == 'table' then
          ---@cast peer_info vim.ServerInfo
          seen[socket] = true
          if want_info then
            table.insert(peers, {
              addr = socket,
              pid = peer_info.pid,
              own = false,
              active = peer_info.active,
            })
          else
            table.insert(peers, socket)
          end
        end
        pcall(vim.fn.chanclose, chan)
      end
    end
  end

  return peers
end

-- (Windows only) Canonical --listen address persisted across restarts.
M.restart_canonical_addr = nil ---@type string?

--- (Windows only)
--- Called on the new server via nvim_exec_lua RPC from the old server (:restart).
--- Windows named pipes can't be rebound immediately, so the new server starts on a
--- temporary bootstrap address and polls until the canonical address is reclaimable.
--- @param canonical_addr string  The original --listen address to reclaim.
--- @param expected_uis   integer Number of UIs expected to reattach (0 = don't wait).
function M.rebind_after_restart(canonical_addr, expected_uis)
  M.restart_canonical_addr = canonical_addr
  local bootstrap_addr = vim.v.servername -- Temporary autogenerated address.
  local poll_ms = 50
  local max_wait_ms = 30000
  local timer = assert(vim.uv.new_timer())

  -- Poll until the canonical address can be reclaimed (or timeout).
  local poll_elapsed = 0
  timer:start(poll_ms, poll_ms, function()
    vim.schedule(function()
      if timer:is_closing() then
        return
      end
      poll_elapsed = poll_elapsed + poll_ms
      if poll_elapsed >= max_wait_ms then
        timer:stop()
        timer:close()
        return
      end
      if not vim.list_contains(vim.fn.serverlist(), canonical_addr) then
        local ok = vim._with({ log_level = 5 }, function()
          return pcall(vim.fn.serverstart, canonical_addr)
        end)
        if not ok then
          return -- pipe still held by old server; retry next tick
        end
      end

      -- Wait for UIs to reattach, then retire the bootstrap address.
      local elapsed = 0
      timer:stop()
      timer:start(poll_ms, poll_ms, function()
        vim.schedule(function()
          if timer:is_closing() then
            return
          end
          elapsed = elapsed + poll_ms
          local all_uis = expected_uis <= 0 or #vim.api.nvim_list_uis() >= expected_uis
          if all_uis or elapsed >= max_wait_ms then
            if canonical_addr ~= bootstrap_addr then
              vim._with({ log_level = 5 }, function()
                pcall(vim.fn.serverstop, bootstrap_addr)
              end)
            end
            timer:stop()
            timer:close()
          end
        end)
      end)
    end)
  end)
end

return M