ask-app-server 0.1.2 → 0.4.2

data/lib/ask/app_server/session_manager.rb

@@ -2,10 +2,12 @@
 
 module Ask
   module AppServer
-    # Manages the lifecycle of agent sessions exposed through the app-server.
+    # Manages the lifecycle of agent sessions exposed through the session
+    # host (ask-app-server).
     #
     # Orchestrates creation, resumption, subscription, messaging, aborting,
-    # and event polling across AgentAdapter instances stored in SessionStore.
+    # interaction resolution (approvals, plan), closing, and event polling
+    # across AgentAdapter instances stored in SessionStore.
     class SessionManager
       # Default tools if none specified.
       DEFAULT_TOOLS = %w[bash read write edit glob grep].freeze
@@ -13,6 +15,9 @@ module Ask
       # Default model if none specified.
       DEFAULT_MODEL = ENV.fetch("ASK_APP_SERVER_MODEL", "opencode_go/deepseek-v4-flash")
 
+      # Tools gated behind human approval when approval is :require.
+      DEFAULT_REQUIRE_APPROVAL = %w[write edit bash destroy].freeze
+
       attr_reader :store
       attr_reader :permission_mode
       attr_reader :blocked_tools
@@ -21,89 +26,86 @@ module Ask
       def initialize(store: nil, permission_mode: :on_request, blocked_tools: nil, permission_timeout: 300)
         @store = store || SessionStore.new
         @permission_mode = permission_mode
-        @blocked_tools = blocked_tools
+        @blocked_tools = (blocked_tools || DEFAULT_REQUIRE_APPROVAL).map(&:to_s)
         @permission_timeout = permission_timeout
-        @permission_handlers = {}  # session_id => PermissionHandler
-        @on_new_handler = nil  # callback for new permission handlers
+        @session_event_observers = []
         @logger = Logger.new($stdout, level: ENV["DEBUG"] ? Logger::DEBUG || Logger::DEBUG : Logger::WARN)
       end
 
-      # Register a callback that fires for every new PermissionHandler created.
-      # The server uses this to wire its protocol sender callback.
-      def on_new_permission_handler(&block)
-        @on_new_handler = block
+      # Register an observer for canonical events across all sessions.
+      # Called with (session_id, Ask::SessionProtocol::Events::Event) for
+      # every emitted event, as it happens.
+      def on_session_event(&block)
+        @session_event_observers << block
       end
 
-      # Set the permission mode for new sessions.
+      # Set the permission mode for new sessions (:on_request, :never, :auto).
       def permission_mode=(mode)
         @permission_mode = mode.to_sym
       end
 
+      # The approval mode new sessions get, translated to the canonical
+      # vocabulary (:off, :require, :auto).
+      def approval_mode
+        translate_permission_mode(@permission_mode)
+      end
+
       # Create a new session.
       # Returns the session ID.
+      #
+      # @param mode [String, Symbol, nil] "on_request"/"build"/"edit"
+      #   (approvals required for blocked tools), "auto", "never"/"off"/"yolo"
+      #   (no approvals), "plan" (plan mode, read-only until approved); nil
+      #   falls back to the manager's permission_mode
       def create_session(workspace_path: nil, mode: nil, model: nil, tools: nil, system_prompt: nil)
-        permission_mode = resolve_permission_mode(mode)
+        approval_opts, plan_mode = resolve_approval(mode)
 
         # Extract provider prefix from model string (e.g., "opencode_go/deepseek-v4-flash")
         model_id, model_provider = parse_model_string(model || DEFAULT_MODEL)
         model_for_agent = model_provider ? model_id : (model || DEFAULT_MODEL)
 
-        # Create the permission handler if needed
-        permission_handler = if permission_mode == :on_request
-          handler_opts = { mode: :on_request }
-          handler_opts[:blocked_tools] = @blocked_tools if @blocked_tools
-          handler_opts[:timeout] = @permission_timeout if @permission_timeout
-
-          handler = PermissionHandler.new(**handler_opts)
-          @permission_handlers[session_id_cache] = handler if session_id_cache
-          handler
-        end
-
-        hooks = {}
-        hooks[:before_tool] = [permission_handler] if permission_handler
-
         adapter = AgentAdapter.new(
           model: model_for_agent,
           tools: tools || DEFAULT_TOOLS,
           system_prompt: system_prompt || build_default_system_prompt(workspace_path),
           agent_dir: workspace_path,
-          hooks: hooks
+          approval: approval_opts[:mode],
+          require_approval: approval_opts[:require_approval],
+          plan_mode: plan_mode
         )
 
         session_id = adapter.start_session
         @store.add(session_id, adapter)
 
-        # Register the permission handler by session ID
-        if permission_handler
-          @permission_handlers[session_id] = permission_handler
-          @on_new_handler&.call(permission_handler)
-        end
+        # Attach observers after registration so they see a settled store
+        # (e.g. the pane reporter's session-count metadata), then replay
+        # the session.created event the adapter buffered during start.
+        adapter.on_event { |event| notify_session_event(adapter.session_id, event) }
+        created = adapter.pending_events.find { |e| e.type == "session.created" }
+        notify_session_event(session_id, created) if created
 
-        @logger.info("Created session #{session_id} (model=#{model || DEFAULT_MODEL}, permission_mode=#{permission_mode})")
+        @logger.info("Created session #{session_id} (model=#{model || DEFAULT_MODEL}, approval=#{approval_opts[:mode]})")
 
         session_id
       end
 
-      # Get the permission handler for a session, if any.
-      def permission_handler_for(session_id)
-        @permission_handlers[session_id]
-      end
-
       # Remove a session.
       def destroy_session(session_id)
         adapter = @store.get(session_id)
         return false unless adapter
 
-        # Cancel any pending permission requests
-        handler = @permission_handlers.delete(session_id)
-        handler&.cancel_all!
-
         adapter.abort_turn! if adapter.running
+        adapter.close!
         @store.remove(session_id)
         @logger.info("Destroyed session #{session_id}")
         true
       end
 
+      # Close a session (protocol alias of destroy_session).
+      def close_session(session_id)
+        destroy_session(session_id)
+      end
+
       # Get an adapter by session ID.
       def get(session_id)
         @store.get(session_id)
@@ -114,28 +116,97 @@ module Ask
         @store.list(limit: limit)
       end
 
-      # Send a message to a session.
-      def send_message(session_id, content)
+      # Send a message to a session (prompt when idle, mid-execution
+      # injection when running).
+      #
+      # @return [Hash] { accepted: Boolean, status: "steered"|"queued"|"stale", turnId: }
+      def send_message(session_id, content, expected_turn_id: nil)
         adapter = @store.get(session_id)
         raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
 
-        if adapter.running
-          @logger.info("Session #{session_id} busy, injecting message")
-          adapter.inject_message(content)
-        else
-          adapter.send_message(content)
-        end
+        result = adapter.send_message(content, expected_turn_id: expected_turn_id)
+        {
+          accepted: result[:status] != "stale",
+          status: result[:status],
+          turnId: result[:turn_id]
+        }
+      end
 
-        true
+      # ── Interactions (approvals) ───────────────────────────────────────
+
+      # Pending approval interactions for a session.
+      def pending_interactions(session_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.pending_interactions
+      end
+
+      # Approve a pending approval interaction by canonical id.
+      # @return [Boolean]
+      def approve_interaction(session_id, interaction_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.approve_interaction(interaction_id)
       end
 
+      # Reject a pending approval interaction by canonical id.
+      # @return [Boolean]
+      def reject_interaction(session_id, interaction_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.reject_interaction(interaction_id)
+      end
+
+      # Approve every pending approval interaction.
+      # @return [Integer] number approved
+      def approve_all_interactions(session_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.approve_all_interactions
+      end
+
+      # Reject every pending approval interaction.
+      # @return [Integer] number rejected
+      def reject_all_interactions(session_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.reject_all_interactions
+      end
+
+      # ── Plan mode ───────────────────────────────────────────────────────
+
+      # Approve the pending plan proposal.
+      # @return [Boolean]
+      def plan_approve(session_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.plan_approve
+      end
+
+      # Reject the pending plan proposal; the agent stays in plan mode.
+      # @return [Boolean]
+      def plan_reject(session_id)
+        adapter = @store.get(session_id)
+        raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
+
+        adapter.plan_reject
+      end
+
+      # ── Events and workspace ───────────────────────────────────────────
+
       # Subscribe to a session's events.
-      def subscribe(session_id, delivery_kind: "web-remote-replayable")
+      def subscribe(session_id, delivery_kind: "replay")
         adapter = @store.get(session_id)
         raise Ask::AppServer::SessionNotFound, "Session #{session_id} not found" unless adapter
 
         @store.subscribe(session_id, delivery_kind: delivery_kind)
-        { subscribed: true, sessionId: session_id, deliveryKind: delivery_kind }
+        { subscription: { sessionId: session_id, deliveryKind: delivery_kind } }
       end
 
       # Get events for a session after a sequence number.
@@ -155,6 +226,21 @@ module Ask
 
       # Read workspace state.
       def read_workspace_state(session_id = nil)
+        workspace = {
+          path: nil,
+          name: nil,
+          gitBranch: nil,
+          mode: approval_mode.to_s
+        }
+
+        if session_id
+          adapter = @store.get(session_id)
+          if adapter
+            workspace[:sessionId] = session_id
+            workspace[:running] = adapter.running
+          end
+        end
+
         settings = {
           model: {
             current: {
@@ -167,15 +253,7 @@ module Ask
           }
         }
 
-        if session_id
-          adapter = @store.get(session_id)
-          if adapter
-            settings[:sessionId] = session_id
-            settings[:running] = adapter.running
-          end
-        end
-
-        { settings: settings }
+        { workspace: workspace, settings: settings }
       end
 
       # Check if a session is subscribed.
@@ -183,22 +261,37 @@ module Ask
         @store.subscribed?(session_id)
       end
 
-      # Notify subscribers of new events.
-      def pending_notifications(session_id)
-        adapter = @store.get(session_id)
-        return [] unless adapter && subscribed?(session_id)
+      private
 
-        adapter.drain_events
+      # Resolve the session mode into approval options + plan mode.
+      #
+      # @return [Array(Hash, Boolean)] [{ mode:, require_approval: }, plan_mode]
+      def resolve_approval(mode)
+        plan_mode = false
+        approval_mode =
+          case mode.to_s
+          when "plan" then plan_mode = true; :off
+          when "yolo", "never", "off" then :off
+          when "build", "edit", "on_request" then :require
+          when "auto" then :auto
+          else translate_permission_mode(@permission_mode)
+          end
+
+        opts = { mode: approval_mode }
+        opts[:require_approval] = @blocked_tools if approval_mode == :require
+        [opts, plan_mode]
       end
 
-      private
+      def translate_permission_mode(mode)
+        case mode.to_s
+        when "never", "off", "yolo" then :off
+        when "auto" then :auto
+        else :require
+        end
+      end
 
-      def resolve_permission_mode(mode)
-        return :never if mode.to_s == "yolo"
-        return :never if mode.to_s == "plan"
-        return :on_request if mode.to_s == "build"
-        return :on_request if mode.to_s == "edit"
-        @permission_mode
+      def notify_session_event(session_id, event)
+        @session_event_observers.each { |observer| observer.call(session_id, event) }
       end
 
       def build_default_system_prompt(workspace_path)
@@ -217,13 +310,6 @@ module Ask
         end
       end
 
-      # Temporary cache for session ID before it's created
-      def session_id_cache
-        @_sid_counter ||= 0
-        @_sid_counter += 1
-        "_pending_#{@_sid_counter}"
-      end
-
       # Parse a model string that may include a provider prefix.
       # "opencode_go/deepseek-v4-flash" => ["deepseek-v4-flash", "opencode_go"]
       # "gpt-4o" => ["gpt-4o", nil]

data/lib/ask/app_server/socket_server.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "fileutils"
+
+module Ask
+  module AppServer
+    # Unix-socket transport for the session host: any number of clients can
+    # attach to the same sessions (terminal TUI, web console, bots) by
+    # connecting to the socket and speaking the canonical session protocol
+    # as NDJSON lines.
+    #
+    # Each accepted connection gets its own reader thread and a Connection
+    # with per-session delivery cursors; the shared protocol engine
+    # ({Server}) routes responses back to the requesting connection and
+    # fans out session/event notifications to every subscribed connection.
+    #
+    # The socket file is removed on start (stale cleanup) and on stop.
+    class SocketServer
+      # Default socket path: ASK_APP_SERVER_SOCKET env var or
+      # ~/.ask-app-server/app-server.sock
+      def self.default_socket_path
+        ENV["ASK_APP_SERVER_SOCKET"] ||
+          File.expand_path("~/.ask-app-server/app-server.sock")
+      end
+
+      attr_reader :socket_path, :protocol
+
+      # @param session_manager [SessionManager, nil] shared session manager
+      # @param socket_path [String, nil] unix socket path
+      def initialize(session_manager: nil, socket_path: nil)
+        @session_manager = session_manager || SessionManager.new
+        @protocol = Server.new(session_manager: @session_manager)
+        @socket_path = socket_path || self.class.default_socket_path
+        @running = false
+        @listener = nil
+        @acceptor = nil
+        @pusher = nil
+        @logger = Logger.new($stdout, level: ENV["DEBUG"] ? Logger::DEBUG : Logger::WARN)
+      end
+
+      # Bind the socket and start accepting connections. Returns
+      # immediately (accept and push run in background threads).
+      def start
+        @running = true
+        FileUtils.mkdir_p(File.dirname(@socket_path))
+        FileUtils.rm_f(@socket_path)  # stale socket from a previous run
+        @listener = UNIXServer.new(@socket_path)
+        @acceptor = Thread.new { accept_loop }
+        @pusher = Thread.new { pusher_loop }
+        @logger.debug("Socket server listening on #{@socket_path}")
+        self
+      end
+
+      # Stop accepting, close all connections, and remove the socket file.
+      def stop
+        @running = false
+        @acceptor&.kill rescue nil
+        @pusher&.kill rescue nil
+        @protocol.connections.each { |conn| @protocol.remove_connection(conn) }
+        @listener&.close rescue nil
+        FileUtils.rm_f(@socket_path) rescue nil
+      end
+
+      # Whether the server is running.
+      def running?
+        @running
+      end
+
+      private
+
+      def accept_loop
+        while @running
+          socket = @listener.accept
+          connection = @protocol.add_connection(Connection.new(socket, socket))
+          reader = Thread.new { reader_loop(connection, socket) }
+          reader.name = "ask-socket-client" if reader.respond_to?(:name=)
+        end
+      rescue IOError, Errno::EBADF, Errno::EINVAL
+        # Listener closed during shutdown.
+      rescue => e
+        @logger.error("Accept error: #{e.message}")
+        sleep 0.1
+      end
+
+      def reader_loop(connection, socket)
+        while @running
+          line = connection.read_line
+          break unless line
+          line = line.strip
+          next if line.empty?
+
+          begin
+            @protocol.dispatch(JSON.parse(line), connection)
+          rescue JSON::ParserError => e
+            @protocol.send(:send_error, nil, -32700, "Parse error: #{e.message}", connection)
+          rescue => e
+            @logger.error("Socket reader error: #{e.message}")
+            break
+          end
+        end
+      ensure
+        @protocol.remove_connection(connection)
+        socket.close rescue nil
+      end
+
+      def pusher_loop
+        while @running
+          @protocol.push_pending
+          sleep 0.1  # 100ms poll interval
+        end
+      end
+    end
+  end
+end

data/lib/ask/app_server/version.rb

@@ -2,6 +2,6 @@
 
 module Ask
   module AppServer
-    VERSION = "0.1.2"
+    VERSION = "0.4.2"
   end
 end

data/lib/ask/app_server.rb

@@ -7,6 +7,8 @@ module Ask
     class SessionNotFound < Error; end
     class SessionAlreadyExists < Error; end
     class SessionNotSubscribed < Error; end
+    class InteractionNotFound < Error; end
+    class PlanNotFound < Error; end
     class InvalidRequest < Error; end
     class TimeoutError < Error; end
   end

data/lib/ask-app-server.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 require "ask/agent"
+require "ask-session-protocol"
 require "ask-tools-shell"
 
 require_relative "ask/app_server/version"
 require_relative "ask/app_server"
 require_relative "ask/app_server/config"
 require_relative "ask/app_server/event_translator"
+require_relative "ask/app_server/connection"
 require_relative "ask/app_server/agent_adapter"
 require_relative "ask/app_server/permission_handler"
 require_relative "ask/app_server/session_store"
 require_relative "ask/app_server/session_manager"
 require_relative "ask/app_server/server"
+require_relative "ask/app_server/socket_server"
+require_relative "ask/app_server/herdr_reporter"
 require_relative "ask/app_server/cli"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ask-app-server
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.4.2
 platform: ruby
 authors:
 - Kaka Ruto
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.40.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: 0.40.1
 - !ruby/object:Gem::Dependency
   name: ask-core
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: ask-tools
+  name: ask-session-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -51,6 +51,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: ask-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.6.1
 - !ruby/object:Gem::Dependency
   name: ask-tools-shell
   requirement: !ruby/object:Gem::Requirement
@@ -168,11 +182,14 @@ files:
 - lib/ask/app_server/agent_adapter.rb
 - lib/ask/app_server/cli.rb
 - lib/ask/app_server/config.rb
+- lib/ask/app_server/connection.rb
 - lib/ask/app_server/event_translator.rb
+- lib/ask/app_server/herdr_reporter.rb
 - lib/ask/app_server/permission_handler.rb
 - lib/ask/app_server/server.rb
 - lib/ask/app_server/session_manager.rb
 - lib/ask/app_server/session_store.rb
+- lib/ask/app_server/socket_server.rb
 - lib/ask/app_server/version.rb
 homepage: https://github.com/ask-rb/ask-app-server
 licenses:
@@ -195,7 +212,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.18
 specification_version: 4
 summary: JSON-RPC app-server for ask-rb agents
 test_files: []