opencode.lua

--[[
================================================================================
OPENCODE PROTOCOL HANDLER - HTTP/SSE IMPLEMENTATION
================================================================================

PURPOSE:
Connects to OpenCode via HTTP/SSE (matching nickjvandyke/opencode.nvim approach).
OpenCode must be started with `--port <N>` to expose its HTTP server.

ARCHITECTURE:
  protocol/opencode.lua (this file)
    - Thin adapter implementing the handler interface
    - Manages lifecycle (start/stop/status) and SSE subscription
    - Delegates diff handling to opencode/diff.lua

  protocol/opencode/server.lua
    - HTTP client for OpenCode REST API
    - SSE subscription
    - Permission reply endpoint

  protocol/opencode/discovery.lua
    - Process discovery (pgrep + lsof)

  protocol/opencode/diff.lua
    - Translates permission.asked events -> DiffManager.show_diff()
    - Translates user_response events -> POST /permission/reply

PROVIDER BEHAVIOR CONFIG (from config.lua):
  opencode = {
    file_operations = "external",     -- OpenCode edits files directly
    diff_dismissal = "auto",          -- Dismiss on external changes
    response_mode = "immediate",     -- Send accept/reject right away
    navigation_trigger = "on_dismiss", -- Navigate when diff is dismissed
    handle_file_operations = false    -- We DON'T write - OpenCode does
  }

DIFF FLOW:
  1. SSE event: permission.asked (permission="edit")
  2. DiffHandler parses metadata.diff + metadata.filepath
  3. DiffManager:show_diff() displays the diff
  4. User accepts/rejects in diff UI -> diff:user_response event
  5. DiffHandler sends POST /permission/<id>/reply
  6. SSE event: permission.replied confirms closure

HANDLER INTERFACE:
  start() -> success, error
  stop() -> success, error
  is_available() -> boolean
  is_connected() -> boolean
  send_message(text) -> success, error
  send_selection(selection_data) -> success, error
  send_at_mention(file_path, start_line, end_line) -> success, error
  get_status() -> table
================================================================================
--]]

local Discovery = require('diffusion.protocol.opencode.discovery')
local DiffHandler = require('diffusion.protocol.opencode.diff')

local OpenCodeHandler = {}

function OpenCodeHandler:new(config, events, diff_manager)
  local instance = {
    _config = config or {},
    _events = events or require('diffusion.utils.events'):new(),
    _logger = require('diffusion.utils.logger'):child("OpenCode"),
    _diff_manager = diff_manager,
    _running = false,
    _connected = false,
    _connection_time = nil,
    _server = nil,
    _sse_job_id = nil,
    _heartbeat_timer = nil,
    _discovery = Discovery:new({}),
    _diff_handler = nil,
    _event_unsubs = {},
    _stats = {
      diffs_created = 0,
      events_received = 0,
      permissions_replied = 0,
      prompts_sent = 0,
    },
  }

  setmetatable(instance, { __index = self })
  return instance
end

local OPENCODE_HEARTBEAT_TIMEOUT_MS = 35000

function OpenCodeHandler:start()
  if self._running then
    self._logger:debug("OpenCode handler already running")
    return true
  end

  self._logger:info("Starting OpenCode handler (HTTP/SSE)")

  if not self._diff_manager then
    local DiffManager = require('diffusion.diff.manager')
    self._diff_manager = DiffManager.get_instance(self._config.diff or {}, self._events)
  end

  local server, err
  local config_port = self._config and self._config.port

  if config_port then
    self._logger:info("Using configured port", { port = config_port })
    local Server = require('diffusion.protocol.opencode.server')
    server = Server:new(config_port)
    local ok, path_info = pcall(function()
      return server:get_path_sync()
    end)
    if ok and path_info then
      server.cwd = path_info.directory or path_info.worktree
    else
      server, err = nil, "OpenCode not responding on port " .. tostring(config_port)
    end
  else
    server, err = self._discovery:find_server()
  end

  if not server then
    self._logger:error("Failed to discover OpenCode server", { error = err })
    vim.notify("OpenCode: " .. (err or "No server found. Start with --port <N>"), vim.log.levels.WARN, { title = "diffusion.nvim" })
    return false, err or "No OpenCode server found"
  end

  self._server = server
  self._logger:info("Connected to OpenCode server", {
    port = server.port,
    cwd = server.cwd,
  })

  self._diff_handler = DiffHandler:new({
    diff_manager = self._diff_manager,
    events = self._events,
  })
  self._diff_handler:set_server(self._server)

  self:_setup_event_handlers()
  self:_start_sse_subscription()
  self:_start_heartbeat_watchdog()

  self._running = true
  self._connected = true
  self._connection_time = os.time()

  self._events:emit("handler:authenticated", { service = "opencode" })

  vim.notify("OpenCode connected on port " .. server.port, vim.log.levels.INFO, { title = "diffusion.nvim" })

  self._logger:info("OpenCode handler started", { port = server.port })
  return true
end

function OpenCodeHandler:_setup_event_handlers()
  self:_cleanup_event_handlers()

  self._event_unsubs[#self._event_unsubs + 1] = self._events:on("diff:user_response", function(data)
    if data.protocol ~= "opencode" then return end

    local handled = self._diff_handler:handle_diff_user_response(data)
    if handled then
      self._stats.permissions_replied = self._stats.permissions_replied + 1
    end
  end)

  self._logger:debug("Event handlers set up")
end

function OpenCodeHandler:_cleanup_event_handlers()
  for _, unsub in ipairs(self._event_unsubs) do
    if type(unsub) == "function" then
      unsub()
    end
  end
  self._event_unsubs = {}
end

function OpenCodeHandler:_start_sse_subscription()
  if not self._server then return end

  self._logger:info("Starting SSE subscription", { port = self._server.port })

  self._sse_job_id = self._server:sse_subscribe(
    function(event)
      self._last_event_time = os.time()
      self._stats.events_received = self._stats.events_received + 1
      self:_handle_sse_event(event)
    end,
    function(code, msg)
      self._logger:warn("SSE stream ended", { code = code, msg = msg })
      if self._running then
        self._logger:info("Attempting SSE reconnection in 3s...")
        vim.defer_fn(function()
          if self._running then
            self:_start_sse_subscription()
          end
        end, 3000)
      end
    end
  )
end

function OpenCodeHandler:_handle_sse_event(event)
  local event_type = event.type
  local props = event.properties or {}

  self._logger:debug("SSE event received", { type = event_type })

  if event_type == "session.heartbeat" then
    return
  end

  if event_type == "session.idle" then
    self._events:emit("opencode:session_idle", {})
    return
  end

  if event_type == "session.diff" then
    self._events:emit("opencode:session_diff", props)
    vim.cmd("checktime")
    return
  end

  if event_type == "permission.asked" then
    if props.permission == "edit" then
      self._diff_handler:handle_permission_asked(event)
    else
      self._logger:debug("Non-edit permission asked", { permission = props.permission })
    end
    return
  end

  if event_type == "permission.replied" then
    self._diff_handler:handle_permission_replied(event)
    return
  end

  if event_type == "session.error" then
    self._logger:error("OpenCode session error", { properties = props })
    self._events:emit("opencode:session_error", props)
    return
  end

  if event_type == "server.instance.disposed" then
    self._logger:warn("OpenCode server instance disposed")
    self._connected = false
    self._events:emit("handler:connection_lost", { service = "opencode" })
    return
  end

  self._logger:debug("Unhandled SSE event type", { type = event_type })
end

function OpenCodeHandler:_start_heartbeat_watchdog()
  if self._heartbeat_timer then
    self._heartbeat_timer:stop()
    self._heartbeat_timer:close()
  end

  self._last_event_time = os.time()
  self._heartbeat_timer = vim.uv.new_timer()

  self._heartbeat_timer:start(
    OPENCODE_HEARTBEAT_TIMEOUT_MS,
    OPENCODE_HEARTBEAT_TIMEOUT_MS,
    vim.schedule_wrap(function()
      if not self._running then return end

      local elapsed = (os.time() - self._last_event_time) * 1000
      if elapsed > OPENCODE_HEARTBEAT_TIMEOUT_MS then
        self._logger:warn("Heartbeat timeout, SSE stream may be dead")
        self._connected = false
        self._events:emit("handler:connection_lost", { service = "opencode" })

        if self._config.auto_reconnect then
          self._logger:info("Attempting reconnection...")
          vim.defer_fn(function()
            if self._running then
              self:stop()
              self:start()
            end
          end, 1000)
        end
      end
    end)
  )
end

function OpenCodeHandler:send_message(message)
  if not self._running or not self._server then
    return false, "OpenCode handler not connected"
  end

  self._logger:info("Sending prompt to OpenCode", { text_len = #message })

  local success = false
  self._server:tui_append_prompt(message, function()
    success = true
    self._logger:debug("Prompt appended, submitting...")
    self._server:tui_execute_command("prompt.submit")
    self._stats.prompts_sent = self._stats.prompts_sent + 1
  end, function(code, msg)
    self._logger:error("Failed to append prompt", { code = code, msg = msg })
  end)

  return true
end

function OpenCodeHandler:send_selection(selection_data)
  if not self._running or not self._server then
    return false, "OpenCode handler not connected"
  end

  self._logger:info("Sending selection", {
    file_path = selection_data.file_path,
    start_line = selection_data.start_line,
    end_line = selection_data.end_line,
  })

  local ref = self:_format_file_reference(
    selection_data.file_path,
    selection_data.start_line,
    selection_data.end_line
  )

  local prompt_text = ref
  if selection_data.text and selection_data.text ~= "" then
    prompt_text = ref .. "\n\n" .. selection_data.text
  end

  return self:send_message(prompt_text)
end

function OpenCodeHandler:send_at_mention(file_path, start_line, end_line)
  if not self._running or not self._server then
    return false, "OpenCode handler not connected"
  end

  self._logger:info("Sending at_mention", {
    file = file_path,
    lines = string.format("%d-%d", start_line, end_line),
  })

  local ref = self:_format_file_reference(file_path, start_line, end_line)
  return self:send_message(ref)
end

function OpenCodeHandler:_format_file_reference(filepath, start_line, end_line)
  local ref = "@" .. filepath
  if start_line then
    if end_line and end_line ~= start_line then
      ref = string.format("@%s:%d-%d", filepath, start_line, end_line)
    else
      ref = string.format("@%s:%d", filepath, start_line)
    end
  end
  return ref
end

function OpenCodeHandler:stop()
  if not self._running then
    return true, nil
  end

  self._logger:info("Stopping OpenCode handler")

  if self._sse_job_id then
    self._server:stop_sse(self._sse_job_id)
    self._sse_job_id = nil
  end

  if self._heartbeat_timer then
    self._heartbeat_timer:stop()
    self._heartbeat_timer:close()
    self._heartbeat_timer = nil
  end

  self:_cleanup_event_handlers()

  if self._diff_handler then
    self._diff_handler:cleanup()
    self._diff_handler = nil
  end

  self._server = nil
  self._running = false
  self._connected = false
  self._connection_time = nil

  self._logger:info("OpenCode handler stopped")
  return true, nil
end

function OpenCodeHandler:is_connected()
  return self._running and self._connected and self._server ~= nil
end

function OpenCodeHandler:is_available()
  if self._running and self._connected then
    return true
  end

  local server, _ = self._discovery:find_server()
  return server ~= nil
end

function OpenCodeHandler:get_status()
  return {
    available = self:is_available(),
    connected = self:is_connected(),

    server_info = {
      http = {
        transport = "http_sse",
        port = self._server and self._server.port,
        cwd = self._server and self._server.cwd,
        sse_active = self._sse_job_id ~= nil,
      },
    },

    workspace_info = {
      path = vim.fn.getcwd(),
      detection_method = "process_discovery",
    },

    stats = self._stats,

    config = {
      enabled = self._config.enabled,
      auto_reconnect = self._config.auto_reconnect,
    },

    running = self._running,
  }
end

function OpenCodeHandler:open_diff(diff_params)
  return self._diff_manager:show_diff(diff_params)
end

return OpenCodeHandler