feat: implement basic permissions worflow

Author: sudo-tee

README.md

@@ -512,6 +512,42 @@ function M.redo()
     end)
 end
 
+---@param answer? 'once'|'always'|'reject'
+function M.respond_to_permission(answer)
+  answer = answer or 'once'
+  if not state.current_permission then
+    vim.notify('No permission request to accept', vim.log.levels.WARN)
+    return
+  end
+
+  ui.render_output(true)
+  state.api_client
+    :respond_to_permission(state.active_session.id, state.current_permission.id, { response = answer })
+    :and_then(function()
+      vim.schedule(function()
+        state.current_permission = nil
+        ui.render_output(true)
+      end)
+    end)
+    :catch(function(err)
+      vim.schedule(function()
+        vim.notify('Failed to reply to permission: ' .. vim.inspect(err), vim.log.levels.ERROR)
+      end)
+    end)
+end
+
+function M.permission_accept()
+  M.respond_to_permission('once')
+end
+
+function M.permission_accept_all()
+  M.respond_to_permission('always')
+end
+
+function M.permission_deny()
+  M.respond_to_permission('reject')
+end
+
 -- Command def/compactinitions that call the API functions
 M.commands = {
   swap_position = {
@@ -912,6 +948,30 @@ M.commands = {
     end,
     slash_cmd = '/redo',
   },
+
+  permission_accept = {
+    name = 'OpencodePermissionAccept',
+    desc = 'Accept current permission request',
+    fn = function()
+      M.respond_to_permission('once')
+    end,
+  },
+
+  permission_accept_all = {
+    name = 'OpencodePermissionAcceptAll',
+    desc = 'Accept all permission requests',
+    fn = function()
+      M.respond_to_permission('always')
+    end,
+  },
+
+  permission_deny = {
+    name = 'OpencodePermissionDeny',
+    desc = 'Deny current permission request',
+    fn = function()
+      M.respond_to_permission('reject')
+    end,
+  },
 }
 
 function M.get_slash_commands()

lua/opencode/api.lua

@@ -361,7 +361,14 @@ function OpencodeApiClient:subscribe_to_events(directory, on_event)
     url = url .. '?directory=' .. directory
   end
 
-  return server_job.stream_api(url, 'GET', nil, on_event)
+  return server_job.stream_api(url, 'GET', nil, function(chunk)
+    -- strip data: prefix if present
+    chunk = chunk:gsub('^data:%s*', '')
+    local ok, event = pcall(vim.json.decode, vim.trim(chunk))
+    if ok and event then
+      on_event(event)
+    end
+  end)
 end
 
 -- Tool endpoints

lua/opencode/api_client.lua

@@ -46,6 +46,9 @@ M.defaults = {
       diff_restore_snapshot_all = '<leader>orR',
       open_configuration_file = '<leader>oC',
       swap_position = '<leader>ox', -- Swap Opencode pane left/right
+      permission_accept = '<leader>opa',
+      permission_accept_all = '<leader>opA',
+      permission_deny = '<leader>opd',
     },
     window = {
       submit = '<cr>',
@@ -66,6 +69,9 @@ M.defaults = {
       debug_message = '<leader>oD',
       debug_output = '<leader>oO',
       debug_session = '<leader>ods',
+      permission_accept = 'a',
+      permission_accept_all = 'A',
+      permission_deny = 'd',
     },
   },
   ui = {

lua/opencode/config.lua

@@ -40,7 +40,6 @@ end
 function M.open(opts)
   opts = opts or { focus = 'input', new_session = false }
 
-  local state = require('opencode.state')
   if not state.opencode_server_job or not state.opencode_server_job:is_running() then
     state.opencode_server_job = server_job.ensure_server() --[[@as OpencodeServer]]
   end
@@ -239,7 +238,7 @@ end
 
 function M.setup()
   local OpencodeApiClient = require('opencode.api_client')
-  state.api_client = OpencodeApiClient.new() --[[@as OpencodeApiClient]]
+  state.api_client = OpencodeApiClient.new()
 end
 
 return M

lua/opencode/core.lua

@@ -0,0 +1,154 @@
+local M = {}
+
+--- Build curl command arguments from options
+--- @param opts table Options for the curl request
+--- @return table args Array of curl command arguments
+local function build_curl_args(opts)
+  local args = { 'curl', '-s', '--no-buffer' }
+
+  if opts.method and opts.method ~= 'GET' then
+    table.insert(args, '-X')
+    table.insert(args, opts.method)
+  end
+
+  if opts.headers then
+    for key, value in pairs(opts.headers) do
+      table.insert(args, '-H')
+      table.insert(args, key .. ': ' .. value)
+    end
+  end
+
+  if opts.body then
+    table.insert(args, '-d')
+    table.insert(args, opts.body)
+  end
+
+  if opts.proxy and opts.proxy ~= '' then
+    table.insert(args, '--proxy')
+    table.insert(args, opts.proxy)
+  end
+
+  table.insert(args, opts.url)
+
+  return args
+end
+
+--- Parse HTTP response headers and body
+--- @param output string Raw curl output with headers
+--- @return table response Response object with status, headers, and body
+local function parse_response(output)
+  local lines = vim.split(output, '\n')
+  local status = 200
+  local headers = {}
+  local body_start = 1
+
+  -- Find status line and headers
+  for i, line in ipairs(lines) do
+    if line:match('^HTTP/') then
+      status = tonumber(line:match('HTTP/[%d%.]+%s+(%d+)')) or 200
+    elseif line:match('^[%w%-]+:') then
+      local key, value = line:match('^([%w%-]+):%s*(.*)$')
+      if key and value then
+        headers[key:lower()] = value
+      end
+    elseif line == '' then
+      body_start = i + 1
+      break
+    end
+  end
+
+  local body_lines = {}
+  for i = body_start, #lines do
+    table.insert(body_lines, lines[i])
+  end
+  local body = table.concat(body_lines, '\n')
+
+  return {
+    status = status,
+    headers = headers,
+    body = body,
+  }
+end
+
+--- Make an HTTP request
+--- @param opts table Request options
+--- @return table|nil job Job object for streaming requests, nil for regular requests
+function M.request(opts)
+  local args = build_curl_args(opts)
+
+  if opts.stream then
+    local buffer = ''
+
+    local job = vim.system(args, {
+      stdout = function(err, chunk)
+        if err then
+          if opts.on_error then
+            opts.on_error({ message = err })
+          end
+          return
+        end
+
+        if chunk then
+          buffer = buffer .. chunk
+
+          -- Extract complete lines
+          while buffer:find('\n') do
+            local line, rest = buffer:match('([^\n]*\n)(.*)')
+            if line then
+              opts.stream(nil, line)
+              buffer = rest
+            else
+              break
+            end
+          end
+        end
+      end,
+      stderr = function(err, data)
+        if err and opts.on_error then
+          opts.on_error({ message = err })
+        end
+      end,
+    }, opts.on_exit and function(result)
+      -- Flush any remaining buffer content
+      if buffer and buffer ~= '' then
+        opts.stream(nil, buffer)
+      end
+      opts.on_exit(result.code, result.signal)
+    end or nil)
+
+    return {
+      _job = job,
+      is_running = function()
+        return job and job.pid ~= nil
+      end,
+      shutdown = function()
+        if job and job.pid then
+          pcall(function()
+            job:kill('sigterm')
+          end)
+        end
+      end,
+    }
+  else
+    table.insert(args, 2, '-i')
+
+    vim.system(args, {
+      text = true,
+    }, function(result)
+      if result.code ~= 0 then
+        if opts.on_error then
+          opts.on_error({ message = result.stderr or 'curl failed' })
+        end
+        return
+      end
+
+      local response = parse_response(result.stdout or '')
+
+      if opts.callback then
+        opts.callback(response)
+      end
+    end)
+  end
+end
+
+return M