[FEATURE] Keep Claude Code running when toggling

[mikkelsvartveit]

Feature Description

Currently, the Claude Code process is killed when running :ClaudeCode or :ClaudeCodeClose. I would prefer if the process kept running in the background even when the panel is hidden.

Use Case

It would be nice to toggle the Claude Code panel without killing it, allowing for jumping back and forth between full-width code buffers and Claude Code.

[cyperx84]

i managed to do a workaround for this in the config, i dunno how useful its going to be as im thinking this should really be a core part of the plugin

  config = function()
    require("claudecode").setup()
    
      local function claude_toggle()
        -- First, find existing Claude buffer
        local claude_buf = nil
        for _, buf in ipairs(vim.api.nvim_list_bufs()) do
          if vim.api.nvim_buf_is_valid(buf) then
            local buf_name = vim.api.nvim_buf_get_name(buf)
            local buf_type = vim.bo[buf].buftype
            -- Look for Claude buffer patterns
            if buf_name:match("claudecode") or 
               buf_name:match("Claude") or 
               (buf_type == "terminal" and buf_name:match("claude")) then
              claude_buf = buf
              break
            end
          end
        end
        
        -- Check if Claude buffer is currently visible in any window
        local claude_win = nil
        if claude_buf then
          for _, win in ipairs(vim.api.nvim_list_wins()) do
            if vim.api.nvim_win_get_buf(win) == claude_buf then
              claude_win = win
              break
            end
          end
        end
        
        if claude_win then
          -- Claude window is visible, close the split window
          local current_win = vim.api.nvim_get_current_win()
          vim.api.nvim_win_close(claude_win, false)
          -- Make sure we stay in our original window
          if vim.api.nvim_win_is_valid(current_win) then
            vim.api.nvim_set_current_win(current_win)
          end
        elseif claude_buf then
          -- Claude buffer exists but not visible, create a split and show it
          vim.cmd("vsplit")
          local new_win = vim.api.nvim_get_current_win()
          vim.api.nvim_win_set_buf(new_win, claude_buf)
          -- Resize the split based on your config
          local width = math.floor(vim.o.columns * 0.3)
          vim.api.nvim_win_set_width(new_win, width)
        else
          -- No Claude buffer exists, create one (this should create its own split)
          vim.cmd("ClaudeCodeOpen")
        end
      end
    
    _G.claude_toggle = claude_toggle
  end,
  keys = {
    { "<c-M-j>", function() _G.claude_toggle() end, desc = "Toggle Claude Window" },
    { "<leader>cs", "<cmd>ClaudeCodeSend<cr>", mode = "v", desc = "Send to Claude" },
    { "<leader>co", "<cmd>ClaudeCodeOpen<cr>", desc = "Open Claude" },
    { "<leader>cx", "<cmd>ClaudeCodeClose<cr>", desc = "Close Claude" },
  },

[cj]

@cyperx84 you must have read my mind! I just tried this and it works for toggling, but when you visually select code (after toggling) and do cs, it opens a claude buffer instead of using the one that's open:

[ThomasK33]

Currently, the Claude Code process is killed when running :ClaudeCode or :ClaudeCodeClose. I would prefer if the process kept running in the background even when the panel is hidden.

Technically, you can toggle the Claude Code terminal window without closing the session. You must be focused on the terminal window, enter normal mode (either via ESC or ctrl+\ ctrl+n), and then run the :ClaudeCode.

My initial idea for this was:

• If the terminal is not open, it should toggle it open.
• If you are not currently in the terminal buffer, it should switch focus to the terminal buffer.
• If you are in the terminal buffer, it should toggle it.

This flow may not be the most intuitive, so I will change the default behavior to only toggle the terminal, with an option for the current flow... maybe. 😅

[cyperx84]

@ThomasK33, I agree with your idea about the toggle functionality. I created a workaround based on your suggestion, and it seems intuitive. While exploring this, I thought it would be great to support multiple Claude buffers with easy switching. Here's what I developed with help from Claude. I'm relatively new to this, so I'm not sure how helpful it might be.

return {
  "coder/claudecode.nvim",
  dependencies = {
    "folke/snacks.nvim", -- Optional for enhanced terminal
  },
  opts = {
    -- Server options
    port_range = { min = 10000, max = 65535 },
    auto_start = true,
    log_level = "info",

    -- Terminal options
    terminal = {
      split_side = "left", -- or "right"
      split_width_percentage = 0.3,
      provider = "native", -- or "snacks"
    },

    -- Diff options
    diff_opts = {
      auto_close_on_accept = true,
      vertical_split = true,
    },
  },
  config = function()
    require("claudecode").setup()
    
    local managed_claude_buffer_id = nil 
    
    local function is_valid_claude_buffer(buf_id)
        if not buf_id or not vim.api.nvim_buf_is_valid(buf_id) then return false end
        if vim.bo[buf_id].buftype ~= "terminal" then return false end
        local name = vim.api.nvim_buf_get_name(buf_id)
        return name:match("term://.*claude") or name:match("ClaudeCode") or name:match("claudecode")
    end

    local function get_managed_claude_buffer()
      if is_valid_claude_buffer(managed_claude_buffer_id) then
        return managed_claude_buffer_id
      end
      
      managed_claude_buffer_id = nil -- Clear if invalid

      -- Fallback: Scan for the most recent existing Claude buffer and adopt it
      local bufs = vim.api.nvim_list_bufs()
      for i = #bufs, 1, -1 do 
        local buf = bufs[i]
        if is_valid_claude_buffer(buf) then
          managed_claude_buffer_id = buf -- Adopt it
          return managed_claude_buffer_id
        end
      end
      return nil -- No managed or existing Claude buffer found
    end
    
    local function find_all_claude_windows_info()
      local windows_info = {}
      for _, win_id in ipairs(vim.api.nvim_list_wins()) do
        if vim.api.nvim_win_is_valid(win_id) then
          local buf_in_win = vim.api.nvim_win_get_buf(win_id)
          if is_valid_claude_buffer(buf_in_win) then -- Use the checker
            table.insert(windows_info, { win_id = win_id, buf_id = buf_in_win })
          end
        end
      end
      return windows_info
    end
    
    -- TermOpen Autocommand: Set managed_claude_buffer_id only if not already managing a valid one.
    vim.api.nvim_create_autocmd({"TermOpen"}, {
      pattern = "*",
      group = vim.api.nvim_create_augroup("ClaudeCodeManager", { clear = true }),
      callback = function(args)
        if is_valid_claude_buffer(args.buf) then
            -- Only set if we don't have a valid managed one, making it "sticky"
            if not is_valid_claude_buffer(managed_claude_buffer_id) then
                managed_claude_buffer_id = args.buf
            end
        end
      end,
    })

    local function claude_toggle()
      local target_buf_id = get_managed_claude_buffer()
      local visible_target_win_id = nil

      if target_buf_id then
          for _, win_info in ipairs(find_all_claude_windows_info()) do
              if win_info.buf_id == target_buf_id then
                  visible_target_win_id = win_info.win_id
                  break
              end
          end
      end
      
      if visible_target_win_id then
        local current_win_before_close = vim.api.nvim_get_current_win()
        pcall(vim.api.nvim_win_close, visible_target_win_id, false)
        if vim.api.nvim_win_is_valid(current_win_before_close) and current_win_before_close ~= visible_target_win_id then
          vim.api.nvim_set_current_win(current_win_before_close)
        end
      elseif target_buf_id then
        vim.cmd("vsplit")
        local new_win = vim.api.nvim_get_current_win()
        vim.api.nvim_win_set_buf(new_win, target_buf_id)
        local width = math.floor(vim.o.columns * 0.3)
        vim.api.nvim_win_set_width(new_win, width)
        vim.api.nvim_set_current_win(new_win)
        vim.cmd("stopinsert")
      else
        vim.cmd("ClaudeCodeOpen") -- TermOpen should set managed_claude_buffer_id
        vim.defer_fn(function()
          local new_opened_buf_id = get_managed_claude_buffer() 
          if new_opened_buf_id then
            for _, win_info in ipairs(find_all_claude_windows_info()) do
                if win_info.buf_id == new_opened_buf_id then
                    vim.api.nvim_set_current_win(win_info.win_id)
                    vim.cmd("stopinsert")
                    break
                end
            end
          end
        end, 300) -- Increased delay for ClaudeCodeOpen to fully initialize
      end
    end
    
    local function claude_send_smart()
        local original_win_id = vim.api.nvim_get_current_win()
        local mode_was_visual = vim.fn.mode():find("[vV]") ~= nil

        if mode_was_visual then
            vim.api.nvim_feedkeys(vim.api.nvim_replace_termcodes("<Esc>", true, false, true), 'nx', false)
        end

        local function core_send_and_cleanup_logic(claude_buf_intended_for_code)
            if not vim.api.nvim_win_is_valid(original_win_id) then return end
            vim.api.nvim_set_current_win(original_win_id)

            if mode_was_visual then
                vim.cmd("normal! gv") 
            end
            
            vim.cmd("ClaudeCodeSend") 

            vim.defer_fn(function() 
                local all_c_wins_info = find_all_claude_windows_info()
                if #all_c_wins_info == 0 then
                    if vim.api.nvim_win_is_valid(original_win_id) then vim.api.nvim_set_current_win(original_win_id) end
                    return
                end

                local final_target_buf_id_to_keep = nil
                local final_win_id_to_keep = nil

                -- Priority 1: The buffer we intended the code for, if it's still valid and in a window
                if is_valid_claude_buffer(claude_buf_intended_for_code) then
                    for _, win_info in ipairs(all_c_wins_info) do
                        if win_info.buf_id == claude_buf_intended_for_code then
                            final_target_buf_id_to_keep = claude_buf_intended_for_code
                            final_win_id_to_keep = win_info.win_id
                            break
                        end
                    end
                end

                -- Priority 2: If intended buffer not found (or became invalid), use current globally managed one
                if not final_win_id_to_keep then
                    local current_managed_buf = get_managed_claude_buffer() -- TermOpen might have updated this
                    if current_managed_buf then
                         for _, win_info in ipairs(all_c_wins_info) do
                            if win_info.buf_id == current_managed_buf then
                                final_target_buf_id_to_keep = current_managed_buf
                                final_win_id_to_keep = win_info.win_id
                                break
                            end
                        end
                    end
                end
                
                -- Priority 3: Absolute fallback
                if not final_win_id_to_keep and #all_c_wins_info > 0 then
                    final_win_id_to_keep = all_c_wins_info[1].win_id
                    final_target_buf_id_to_keep = all_c_wins_info[1].buf_id
                end

                if not final_win_id_to_keep then
                     if vim.api.nvim_win_is_valid(original_win_id) then vim.api.nvim_set_current_win(original_win_id) end
                     return
                end

                for _, win_info in ipairs(all_c_wins_info) do
                    if win_info.win_id ~= final_win_id_to_keep then
                        pcall(vim.api.nvim_win_close, win_info.win_id, false)
                    end
                end
                
                if vim.api.nvim_win_is_valid(final_win_id_to_keep) then
                    if vim.api.nvim_win_get_buf(final_win_id_to_keep) ~= final_target_buf_id_to_keep then
                         pcall(vim.api.nvim_win_set_buf, final_win_id_to_keep, final_target_buf_id_to_keep)
                    end
                    vim.api.nvim_set_current_win(final_win_id_to_keep)
                    vim.cmd("stopinsert")
                else
                    if vim.api.nvim_win_is_valid(original_win_id) then vim.api.nvim_set_current_win(original_win_id) end
                end
            end, 450)
        end

        vim.schedule(function() 
            local claude_buf_for_visibility_check = get_managed_claude_buffer()
            local claude_is_visible = false
            if claude_buf_for_visibility_check then
                for _, win_info in ipairs(find_all_claude_windows_info()) do
                    if win_info.buf_id == claude_buf_for_visibility_check then
                        claude_is_visible = true
                        break
                    end
                end
            end

            if claude_is_visible then
                core_send_and_cleanup_logic(claude_buf_for_visibility_check)
            else
                local buf_to_open = get_managed_claude_buffer()
                if buf_to_open then
                    vim.cmd("vsplit")
                    local new_win = vim.api.nvim_get_current_win()
                    vim.api.nvim_win_set_buf(new_win, buf_to_open)
                    local width = math.floor(vim.o.columns * 0.3)
                    vim.api.nvim_win_set_width(new_win, width)
                else
                    vim.cmd("ClaudeCodeOpen")
                end
                vim.defer_fn(function()
                    -- After opening, the buffer that should receive code is the newly managed one
                    local newly_managed_buf = get_managed_claude_buffer()
                    core_send_and_cleanup_logic(newly_managed_buf)
                end, 350) -- Increased delay for opening actions
            end
        end)
    end
    
    _G.claude_toggle = claude_toggle
    _G.claude_send_smart = claude_send_smart
  end,
  keys = {
    { "<c-M-j>", function() _G.claude_toggle() end, desc = "Toggle Claude Window" },
    { "<leader>cs", function() _G.claude_send_smart() end, mode = "v", desc = "Send to Claude" },
  },
}

[ThomasK33]

I'm relatively new to this, so I'm not sure how helpful it might be.

Don't worry about that, I'm new to this (neovim, Lua, etc.) too. 😄

it would be great to support multiple Claude buffers with easy switching

That's unfortunately a current limitation of Claude Code. The moment a new client connects to this IDE WebSocket MCP, the other one gets disconnected (at least that's the behavior for the VS Code integration).

[mikkelsvartveit]

Currently, the Claude Code process is killed when running :ClaudeCode or :ClaudeCodeClose. I would prefer if the process kept running in the background even when the panel is hidden.

Technically, you can toggle the Claude Code terminal window without closing the session. You must be focused on the terminal window, enter normal mode (either via ESC or ctrl+\ ctrl+n), and then run the :ClaudeCode.

My initial idea for this was:

• If the terminal is not open, it should toggle it open.
• If you are not currently in the terminal buffer, it should switch focus to the terminal buffer.
• If you are in the terminal buffer, it should toggle it.

This flow may not be the most intuitive, so I will change the default behavior to only toggle the terminal, with an option for the current flow... maybe. 😅

@ThomasK33 I've noticed that it is indeed possible to toggle Claude Code if using snacks as the terminal provider. So adding the snacks dependency actually solved my issue. The current flow is perfect and exactly what I want.

With the native terminal however, entering normal mode and running :ClaudeCode indeed closes the Claude Code session, and running :ClaudeCode again restarts Claude Code. I don't know if this is intended behavior or a limitation that's hard to circumvent, and I'm fine with it since the snacks workaround did the trick, but just wanted to let you know :)

[ThomasK33]

With the native terminal however, entering normal mode and running :ClaudeCode indeed closes the Claude Code session, and running :ClaudeCode again restarts Claude Code. I don't know if this is intended behavior or a limitation that's hard to circumvent, and I'm fine with it since the snacks workaround did the trick, but just wanted to let you know :)

I don't think it's a technical limitation; it's more likely that I haven't tested the native provider enough to spot that, as I'm using snacks.nvim myself.

I'll look into getting this fixed soon. (and maybe even add snacks.nvim to the "quick-start" with a comment that it's optional for a better getting-started experience)