neogit hangs if git hook requires user input

Description

Requiring user input in git hooks is generally regarded as an abuse but one that is pretty common in repositories that use the tool Commitizen which suggests creating a prepare-commit-msg hook that brings in the tty and requests user input. Unfortunately my org is rife with them and I don't have control of most of the repos I work in.

• Even with a 2000ms timeout the console does not cancel.
• Using --no-verify does not work!

Most Git UI tools I've tested tend to hang on this. Lazygit offers the ability to defer to a terminal instance and system Editor with shift+c but all other operations that require a commit message (merge, rebase, etc) hang.

Neovim version

NVIM v0.10.4
Build type: Release
LuaJIT 2.1.1736781742

Operating system and version

macOS 14.7.1 (also tested on Pop_OS! 22.0.4 LTS)

Steps to reproduce

Here is a minimal reproduction:
https://github.com/jaredmcateer/cz-gitui

• checkout
• npm install
• modify/add file
• stage
• commit
• observe neogit is stuck

Even if you close the neogit buffers the git commit ... is present (If progress spinner is enabled). If you check your processes you will see it an instance of git stuck in the terminal.

Expected behavior

Ideally I could unlock the NeogitConsole and it would accept user input and I could proceed with the workflow.

Less ideally I would have some ability to provide environment variables to the command so I could disable this hook (e.g., HUSKY=0), this is less ideal because there are often other hooks that run linters and tests that I'd prefer not to skip.

Finally failing all that NeogitConsole should timeout and I don't have to kill processes

Actual behavior

Neogit does not timeout, process is stuck until killed.

Minimal config

-- NOTE: See the end of this file if you are reporting an issue, etc. Ignore all the "scary" functions up top, those are
-- used for setup and other operations.
local M = {}

local base_root_path = vim.fn.fnamemodify(debug.getinfo(1, "S").source:sub(2), ":p:h") .. "/.min"
function M.root(path)
  return base_root_path .. "/" .. (path or "")
end

function M.load_plugin(plugin_name, plugin_url)
  local package_root = M.root("plugins/")
  local install_destination = package_root .. plugin_name
  vim.opt.runtimepath:append(install_destination)

  if not vim.loop.fs_stat(package_root) then
    vim.fn.mkdir(package_root, "p")
  end

  if not vim.loop.fs_stat(install_destination) then
    print(string.format("> Downloading plugin '%s' to '%s'", plugin_name, install_destination))
    vim.fn.system({
      "git",
      "clone",
      "--depth=1",
      plugin_url,
      install_destination,
    })
    if vim.v.shell_error > 0 then
      error(string.format("> Failed to clone plugin: '%s' in '%s'!", plugin_name, install_destination),
        vim.log.levels.ERROR)
    end
  end
end

---@alias PluginName string The plugin name, will be used as part of the git clone destination
---@alias PluginUrl string The git url at which a plugin is located, can be a path. See https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols for details
---@alias MinPlugins table<PluginName, PluginUrl>

---Do the initial setup. Downloads plugins, ensures the minimal init does not pollute the filesystem by keeping
---everything self contained to the CWD of the minimal init file. Run prior to running tests, reproducing issues, etc.
---@param plugins? table<PluginName, PluginUrl>
function M.setup(plugins)
  vim.opt.packpath = {}                      -- Empty the package path so we use only the plugins specified
  vim.opt.runtimepath:append(M.root(".min")) -- Ensure the runtime detects the root min dir

  -- Install required plugins
  if plugins ~= nil then
    for plugin_name, plugin_url in pairs(plugins) do
      M.load_plugin(plugin_name, plugin_url)
    end
  end

  vim.env.XDG_CONFIG_HOME = M.root("xdg/config")
  vim.env.XDG_DATA_HOME = M.root("xdg/data")
  vim.env.XDG_STATE_HOME = M.root("xdg/state")
  vim.env.XDG_CACHE_HOME = M.root("xdg/cache")

  -- NOTE: Cleanup the xdg cache on exit so new runs of the minimal init doesn't share any previous state, e.g. shada
  vim.api.nvim_create_autocmd("VimLeave", {
    callback = function()
      vim.fn.system({
        "rm",
        "-r",
        "-f",
        M.root("xdg")
      })
    end
  })
end

-- NOTE: If you have additional plugins you need to install to reproduce your issue, include them in the plugins
-- table within the setup call below.
M.setup({
  neogit = "https://github.com/NeogitOrg/neogit"
})
-- WARN: Do all plugin setup, test runs, reproductions, etc. AFTER calling setup with a list of plugins!
-- Basically, do all that stuff AFTER this line.
require("neogit").setup({}) -- For instance, setup Neogit

Start by reproducing the hang with the linked cz-gitui setup and a git hook that requests input, then inspect how NeogitConsole launches and monitors git commit operations. Compare the behavior with the reported 2000ms timeout and --no-verify case. Done means the operation no longer leaves a stuck git process, either by supporting input, allowing cancellation, or reliably timing out.