brute_rack 0.1.0

data/lib/brute_rack/endpoints/global.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "async"
+
+module BruteRack
+  module Endpoints
+    # GET /global/health  → { healthy: true, version: "..." }
+    # GET /global/event   → SSE stream of all bus events
+    module Global
+      def self.health(_env, **)
+        [200, HEADERS_JSON,
+         [JSON.generate(healthy: true, version: Brute::VERSION)]]
+      end
+
+      def self.event(_env, event_bus:, **)
+        sse = BruteRack::SSE.new
+
+        subscriber = event_bus.subscribe do |event|
+          sse.event(event[:type], **(event[:data] || {}), session_id: event[:session_id])
+        end
+
+        # Send initial connected event
+        sse.event("server.connected", version: Brute::VERSION)
+
+        # Keep the stream open until the client disconnects.
+        # Falcon will detect the closed connection and raise Async::Stop
+        # which tears down the task, at which point we unsubscribe.
+        Async do
+          sleep # block forever — events are pushed by the bus
+        rescue
+          # Client disconnected or server shutting down
+        ensure
+          event_bus.unsubscribe(subscriber)
+          sse.close
+        end
+
+        [200, {"content-type" => "text/event-stream", "cache-control" => "no-cache"}, sse.body]
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/logging.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module BruteRack
+  module Endpoints
+    # POST /log → { service, level, message, extra? }
+    module Logging
+      LEVELS = %w[debug info warn error fatal].freeze
+
+      def self.create(env, logger:, **)
+        input = env["rack.input"].read
+        body = input.empty? ? {} : JSON.parse(input)
+
+        level = body["level"] || "info"
+        level = "info" unless LEVELS.include?(level)
+        message = "[#{body["service"] || "client"}] #{body["message"]}"
+
+        logger.send(level.to_sym, message)
+
+        [200, HEADERS_JSON, [JSON.generate(true)]]
+      rescue => e
+        [500, HEADERS_JSON, [JSON.generate(error: e.message)]]
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/messages.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "async"
+require "securerandom"
+
+module BruteRack
+  module Endpoints
+    # GET    /session/:id/message             → list messages
+    # POST   /session/:id/message             → send message (blocking)
+    # GET    /session/:id/message/:messageID  → get specific message
+    # POST   /session/:id/prompt_async        → send message (fire-and-forget)
+    # POST   /session/:id/shell               → execute shell command
+    module Messages
+      def self.list(_env, id:, registry:, **)
+        orch = registry.get(id)
+        return [404, HEADERS_JSON, [JSON.generate(error: "session not found")]] unless orch
+
+        orch.context.messages.to_a.compact.each_with_index.map do |msg, i|
+          {
+            id: i,
+            role: msg.respond_to?(:role) ? msg.role.to_s : "unknown",
+            content: msg.respond_to?(:content) ? msg.content.to_s[0..10_000] : nil,
+            has_tool_calls: msg.respond_to?(:functions) && msg.functions&.any?,
+          }
+        end.then do |messages|
+          [200, HEADERS_JSON, [JSON.generate(messages)]]
+        end
+      end
+
+      def self.send_message(env, id:, registry:, cwd:, **)
+        parse_body(env).then do |body|
+          parts = body["parts"]
+          text = if parts.is_a?(Array)
+            parts.filter_map { |p| p["text"] if p["type"] == "text" }.join("\n")
+          else
+            body["message"] || body.dig("parts", 0, "text") || ""
+          end
+
+          registry.run(id, text, cwd: body["cwd"] || cwd).then do |response|
+            message_id = SecureRandom.uuid
+            {
+              info: { id: message_id, role: "assistant", session_id: id },
+              parts: [{ type: "text", text: response&.content }],
+            }.then do |result|
+              [200, HEADERS_JSON, [JSON.generate(result)]]
+            end
+          end
+        end
+      rescue => e
+        [500, HEADERS_JSON, [JSON.generate(error: e.message)]]
+      end
+
+      def self.get_message(_env, id:, message_id:, registry:, **)
+        orch = registry.get(id)
+        return [404, HEADERS_JSON, [JSON.generate(error: "session not found")]] unless orch
+
+        idx = message_id.match?(/\A\d+\z/) ? message_id.to_i : nil
+        msg = idx ? orch.context.messages.to_a.compact[idx] : nil
+
+        if msg
+          {
+            info: { id: message_id, role: msg.respond_to?(:role) ? msg.role.to_s : "unknown", session_id: id },
+            parts: [{ type: "text", text: msg.respond_to?(:content) ? msg.content.to_s : nil }],
+          }.then { |result| [200, HEADERS_JSON, [JSON.generate(result)]] }
+        else
+          [404, HEADERS_JSON, [JSON.generate(error: "message not found")]]
+        end
+      end
+
+      def self.prompt_async(env, id:, registry:, cwd:, event_bus:, **)
+        parse_body(env).then do |body|
+          text = body["message"] || body.dig("parts", 0, "text") || ""
+
+          Async do
+            registry.run(id, text, cwd: body["cwd"] || cwd)
+          rescue => e
+            event_bus.publish(type: "message.error", session_id: id, data: { error: e.message })
+          end
+
+          [204, {}, []]
+        end
+      end
+
+      def self.shell(env, id:, registry:, cwd:, **)
+        parse_body(env).then do |body|
+          Brute::Tools::Shell.new.call(
+            command: body["command"],
+            cwd: body["cwd"] || cwd,
+          ).then do |result|
+            message_id = SecureRandom.uuid
+            {
+              info: { id: message_id, role: "tool", session_id: id },
+              parts: [{ type: "tool-result", name: "shell", result: result }],
+            }.then { |r| [200, HEADERS_JSON, [JSON.generate(r)]] }
+          end
+        end
+      rescue => e
+        [500, HEADERS_JSON, [JSON.generate(error: e.message)]]
+      end
+
+      def self.parse_body(env)
+        input = env["rack.input"].read
+        input.empty? ? {} : JSON.parse(input)
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/path_vcs.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module BruteRack
+  module Endpoints
+    # GET /path → { cwd: "..." }
+    # GET /vcs  → { branch, remote, dirty, ... }
+    module PathVcs
+      def self.path(_env, cwd:, **)
+        [200, HEADERS_JSON, [JSON.generate(cwd: cwd)]]
+      end
+
+      def self.vcs(_env, cwd:, **)
+        branch, _ = Open3.capture2("git", "rev-parse", "--abbrev-ref", "HEAD", chdir: cwd)
+        remote, _ = Open3.capture2("git", "remote", "get-url", "origin", chdir: cwd)
+        status, _ = Open3.capture2("git", "status", "--porcelain", chdir: cwd)
+        sha, _    = Open3.capture2("git", "rev-parse", "--short", "HEAD", chdir: cwd)
+
+        {
+          branch: branch.strip,
+          remote: remote.strip,
+          sha: sha.strip,
+          dirty: !status.strip.empty?,
+          changed_files: status.lines.size,
+        }.then { |info| [200, HEADERS_JSON, [JSON.generate(info)]] }
+      rescue => e
+        [200, HEADERS_JSON, [JSON.generate(error: "not a git repository", message: e.message)]]
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/provider.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module BruteRack
+  module Endpoints
+    # GET /provider → { all: [...], default: {...}, connected: [...] }
+    module Provider
+      def self.list(_env, **)
+        all_providers = Endpoints::Config.available_providers
+        connected = all_providers.map { |p| p[:id] }
+        defaults = all_providers.each_with_object({}) { |p, h| h[p[:id]] = p[:models].first }
+
+        [200, HEADERS_JSON, [JSON.generate(all: all_providers, default: defaults, connected: connected)]]
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/sessions.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module BruteRack
+  module Endpoints
+    # GET    /session           → list sessions
+    # POST   /session           → create session { parentID?, title? }
+    # GET    /session/status    → { session_id: status, ... }
+    # GET    /session/:id       → session details
+    # PATCH  /session/:id       → update title { title }
+    # DELETE /session/:id       → delete session
+    # POST   /session/:id/abort → abort running session
+    # POST   /session/:id/fork  → fork session { messageID? }
+    # POST   /session/:id/summarize → compact session { providerID, modelID }
+    # GET    /session/:id/todo  → todo list
+    module Sessions
+      def self.list(_env, **)
+        Brute::Session.list.then do |sessions|
+          [200, HEADERS_JSON, [JSON.generate(sessions)]]
+        end
+      end
+
+      def self.create(env, registry:, **)
+        parse_body(env).then do |body|
+          id = SecureRandom.uuid
+          # Don't eagerly create orchestrator — that requires an API key.
+          # The orchestrator is created lazily when a message is sent.
+          Brute::Session.new(id: id)
+          [200, HEADERS_JSON, [JSON.generate(id: id, title: body["title"])]]
+        end
+      end
+
+      def self.status(_env, registry:, **)
+        [200, HEADERS_JSON, [JSON.generate(registry.all_statuses)]]
+      end
+
+      def self.get(_env, id:, **)
+        Brute::Session.list.then do |sessions|
+          sessions.find { |s| s[:id] == id }.then do |found|
+            if found
+              [200, HEADERS_JSON, [JSON.generate(found)]]
+            else
+              [404, HEADERS_JSON, [JSON.generate(error: "session not found")]]
+            end
+          end
+        end
+      end
+
+      def self.update(env, id:, **)
+        parse_body(env).then do |body|
+          # We store title in the metadata sidecar
+          meta_dir = File.join(Dir.home, ".forge", "sessions")
+          meta_path = File.join(meta_dir, "#{id}.meta.json")
+          if File.exist?(meta_path)
+            JSON.parse(File.read(meta_path)).then do |meta|
+              meta["title"] = body["title"] if body["title"]
+              File.write(meta_path, JSON.generate(meta))
+              [200, HEADERS_JSON, [JSON.generate(meta)]]
+            end
+          else
+            [404, HEADERS_JSON, [JSON.generate(error: "session not found")]]
+          end
+        end
+      end
+
+      def self.delete(_env, id:, registry:, **)
+        registry.remove(id)
+        Brute::Session.new(id: id).delete
+        [200, HEADERS_JSON, [JSON.generate(true)]]
+      end
+
+      def self.abort(_env, id:, registry:, **)
+        registry.abort(id)
+        [200, HEADERS_JSON, [JSON.generate(true)]]
+      end
+
+      def self.fork(env, id:, registry:, **)
+        parse_body(env).then do |body|
+          new_id = SecureRandom.uuid
+          # Create a new session, optionally copying from source
+          registry.get_or_create(new_id)
+          source_session = registry.session(id)
+          if source_session && File.exist?(source_session.path)
+            new_session = registry.session(new_id)
+            FileUtils.cp(source_session.path, new_session.path)
+            meta_src = source_session.path.sub(/\.json$/, ".meta.json")
+            if File.exist?(meta_src)
+              meta_dst = new_session.path.sub(/\.json$/, ".meta.json")
+              FileUtils.cp(meta_src, meta_dst)
+            end
+          end
+          [200, HEADERS_JSON, [JSON.generate(id: new_id, forked_from: id)]]
+        end
+      end
+
+      def self.summarize(env, id:, registry:, **)
+        orch = registry.get(id)
+        return [404, HEADERS_JSON, [JSON.generate(error: "session not found")]] unless orch
+
+        compactor = Brute::Compactor.new(Brute.provider)
+        messages = orch.context.messages.to_a.compact
+        compactor.compact(messages).then do |result|
+          if result
+            [200, HEADERS_JSON, [JSON.generate(true)]]
+          else
+            [200, HEADERS_JSON, [JSON.generate(false)]]
+          end
+        end
+      end
+
+      def self.todo(_env, id:, **)
+        [200, HEADERS_JSON, [JSON.generate(Brute::TodoStore.all)]]
+      end
+
+      def self.parse_body(env)
+        input = env["rack.input"].read
+        input.empty? ? {} : JSON.parse(input)
+      end
+    end
+  end
+end

data/lib/brute_rack/endpoints/tools.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BruteRack
+  module Endpoints
+    # GET /experimental/tool/ids              → list tool names
+    # GET /experimental/tool?provider=&model= → list tools with schemas
+    module Tools
+      def self.ids(_env, **)
+        names = LLM::Function.registry.map(&:name)
+        [200, HEADERS_JSON, [JSON.generate(names)]]
+      end
+
+      def self.list(_env, **)
+        tools = LLM::Function.registry.map do |fn|
+          schema = if fn.params
+            { type: "object", properties: serialize_params(fn.params) }
+          else
+            { type: "object", properties: {} }
+          end
+
+          {
+            name: fn.name,
+            description: fn.description,
+            input_schema: schema,
+          }
+        end
+        [200, HEADERS_JSON, [JSON.generate(tools)]]
+      end
+
+      def self.serialize_params(params)
+        return {} unless params.respond_to?(:properties)
+        params.properties.transform_values do |prop|
+          {
+            type: prop.class.name.split("::").last.downcase,
+            description: prop.respond_to?(:description) ? prop.description : nil,
+            required: prop.respond_to?(:required) ? prop.required : nil,
+          }.compact
+        end
+      rescue
+        {}
+      end
+    end
+  end
+end

data/lib/brute_rack/event_bus.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BruteRack
+  # In-memory pub/sub event bus. Endpoints publish events, SSE streams subscribe.
+  #
+  #   bus = EventBus.new
+  #   bus.subscribe { |event| puts event }
+  #   bus.publish(type: "content.delta", session_id: "abc", data: { text: "hi" })
+  #
+  class EventBus
+    def initialize
+      @subscribers = []
+      @mutex = Mutex.new
+    end
+
+    def publish(event)
+      @mutex.synchronize { @subscribers.each { |cb| cb.call(event) } }
+    end
+
+    def subscribe(&block)
+      @mutex.synchronize { @subscribers << block }
+      block
+    end
+
+    def unsubscribe(block)
+      @mutex.synchronize { @subscribers.delete(block) }
+    end
+
+    def subscriber_count
+      @mutex.synchronize { @subscribers.size }
+    end
+  end
+end

data/lib/brute_rack/session_registry.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module BruteRack
+  # Tracks active orchestrators per session. Enables abort, status queries,
+  # and multi-session management without creating throwaway orchestrators.
+  #
+  #   registry = SessionRegistry.new(event_bus: bus, cwd: "/project")
+  #   orch = registry.get_or_create("session-id")
+  #   registry.status("session-id")  # => :idle
+  #
+  class SessionRegistry
+    STATUSES = %i[idle running completed errored].freeze
+
+    def initialize(event_bus:, cwd: Dir.pwd, agent_options: {})
+      @event_bus = event_bus
+      @cwd = cwd
+      @agent_options = agent_options
+      @sessions = {}  # id => { orchestrator:, status:, session: }
+      @mutex = Mutex.new
+    end
+
+    def get_or_create(id, cwd: nil)
+      @mutex.synchronize do
+        @sessions[id] ||= build_entry(id, cwd || @cwd)
+        @sessions[id][:orchestrator]
+      end
+    end
+
+    def get(id)
+      @mutex.synchronize { @sessions.dig(id, :orchestrator) }
+    end
+
+    def session(id)
+      @mutex.synchronize { @sessions.dig(id, :session) }
+    end
+
+    def status(id)
+      @mutex.synchronize { @sessions.dig(id, :status) || :unknown }
+    end
+
+    def set_status(id, status)
+      @mutex.synchronize do
+        @sessions[id][:status] = status if @sessions[id]
+      end
+      @event_bus.publish(type: "session.status", session_id: id, data: { status: status })
+    end
+
+    def all_statuses
+      @mutex.synchronize do
+        @sessions.transform_values { |v| v[:status] }
+      end
+    end
+
+    def ids
+      @mutex.synchronize { @sessions.keys }
+    end
+
+    def remove(id)
+      @mutex.synchronize { @sessions.delete(id) }
+    end
+
+    def abort(id)
+      @mutex.synchronize { @sessions.dig(id, :orchestrator) }&.abort!
+      set_status(id, :idle)
+      true
+    end
+
+    # Run a message through a session's orchestrator with event publishing.
+    def run(id, message, cwd: nil)
+      orch = get_or_create(id, cwd: cwd)
+      set_status(id, :running)
+      @event_bus.publish(type: "message.start", session_id: id, data: { message: message })
+
+      orch.run(message).then do |response|
+        set_status(id, :idle)
+        @event_bus.publish(type: "message.complete", session_id: id, data: {})
+        response
+      end
+    rescue => e
+      set_status(id, :errored)
+      @event_bus.publish(type: "message.error", session_id: id, data: { error: e.message })
+      raise
+    end
+
+    private
+
+    def build_entry(id, cwd)
+      session = Brute::Session.new(id: id, dir: @agent_options[:session_dir])
+      orch = Brute.agent(
+        cwd: cwd,
+        session: session,
+        **@agent_options.except(:session_dir),
+        on_content: ->(text) {
+          @event_bus.publish(type: "content.delta", session_id: id, data: { text: text }) if text
+        },
+        on_tool_call: ->(name, args) {
+          @event_bus.publish(type: "tool.call", session_id: id, data: { name: name, args: args.is_a?(Hash) ? args : {} })
+        },
+        on_tool_result: ->(name, result) {
+          success = !(result.is_a?(Hash) && result[:error])
+          @event_bus.publish(type: "tool.result", session_id: id, data: { name: name, success: success })
+        },
+      )
+      { orchestrator: orch, session: session, status: :idle }
+    end
+  end
+end

data/lib/brute_rack/sse.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "async/http/body/writable"
+require "json"
+
+module BruteRack
+  # Server-Sent Events helper.
+  #
+  # Wraps Async::HTTP::Body::Writable to produce SSE-formatted chunks.
+  # Falcon streams each write to the client immediately — no buffering.
+  #
+  #   sse = BruteRack::SSE.new
+  #   sse.event("content", text: "Hello")   # writes "event: content\ndata: {...}\n\n"
+  #   sse.close                              # signals end of stream
+  #   sse.body                               # the streamable body for Rack response
+  #
+  class SSE
+    attr_reader :body
+
+    def initialize
+      @body = Async::HTTP::Body::Writable.new
+    end
+
+    def event(type, **data)
+      @body.write("event: #{type}\ndata: #{JSON.generate(data)}\n\n")
+    end
+
+    def close
+      @body.close
+    end
+  end
+end

data/lib/brute_rack.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "brute"
+require "json"
+require "rack"
+
+module BruteRack
+  VERSION = "0.1.0"
+
+  # Not frozen — WEBrick mutates response headers.
+  HEADERS_JSON = {"content-type" => "application/json"}
+
+  module Endpoints
+    HEADERS_JSON = BruteRack::HEADERS_JSON
+  end
+end
+
+# Infrastructure
+require_relative "brute_rack/sse"
+require_relative "brute_rack/event_bus"
+require_relative "brute_rack/session_registry"
+
+# Endpoints (OpenCode-compatible API)
+require_relative "brute_rack/endpoints/global"
+require_relative "brute_rack/endpoints/sessions"
+require_relative "brute_rack/endpoints/messages"
+require_relative "brute_rack/endpoints/files"
+require_relative "brute_rack/endpoints/tools"
+require_relative "brute_rack/endpoints/config"
+require_relative "brute_rack/endpoints/provider"
+require_relative "brute_rack/endpoints/path_vcs"
+require_relative "brute_rack/endpoints/logging"
+require_relative "brute_rack/endpoints/flow"
+
+# Rack app (router)
+require_relative "brute_rack/app"