kward 0.76.0 → 0.78.0

data/lib/kward/pan/server.rb

@@ -13,22 +13,28 @@ require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../rpc/transcript_normalizer"
 require_relative "../session_store"
+require_relative "../session_trash"
 require_relative "../tools/tool_call"
 require_relative "../tools/registry"
+require_relative "../version"
 require_relative "../workspace"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Minimal local HTTP server for the experimental Pan web UI.
+  # Local HTTP server for the mobile-friendly Pan web UI.
   class PanServer
     DEFAULT_HOST = "0.0.0.0"
     DEFAULT_PORT = 8765
     MAX_REQUEST_BODY_BYTES = 64 * 1024
+    ROUTING_PROBE_ADDRESS = "8.8.8.8"
+    ROUTING_PROBE_PORT = 80
 
-    def initialize(client:, working_directory:, config: ConfigFiles.read_config, config_dir: ConfigFiles.config_dir, output: $stderr)
+    def initialize(client:, working_directory:, config: ConfigFiles.read_config, config_dir: ConfigFiles.config_dir, output: $stderr, udp_socket_class: UDPSocket)
       @client = client
       @output = output
+      @udp_socket_class = udp_socket_class
       @workspace = Workspace.new(root: working_directory)
+      @full_config = config
       @config = pan_config(config)
       @host = @config.fetch("host", DEFAULT_HOST).to_s
       @port = positive_port(@config.fetch("port", DEFAULT_PORT))
@@ -37,28 +43,22 @@ module Kward
       raise "Pan mode requires pan_mode.username and pan_mode.password in #{ConfigFiles.config_path}" if @username.empty? || @password.empty?
 
       @session_store = SessionStore.new(config_dir: config_dir, cwd: @workspace.root.to_s)
-      @session = @session_store.create
-      @conversation = Conversation.new(
-        workspace_root: @workspace.root.to_s,
+      @session = @session_store.create(
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
         model: (@client.current_model if @client.respond_to?(:current_model)),
         reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
       )
+      @conversation = new_conversation
       @session.attach(@conversation)
-      hook_context = lifecycle_hook_context
-      hook_manager = lifecycle_hook_manager
-      @agent = Agent.new(
-        client: @client,
-        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
-        conversation: @conversation,
-        hook_manager: hook_manager,
-        hook_context: hook_context
-      )
+      @agent = build_agent
       @prompt_queue = Queue.new
       @subscribers = []
       @subscribers_mutex = Mutex.new
       @worker_started = false
       @active = false
+      @pending_turns = 0
       @state_mutex = Mutex.new
+      @session_mutex = Mutex.new
     end
 
     attr_reader :host, :port, :session, :workspace
@@ -91,8 +91,11 @@ module Kward
       text = prompt.to_s
       return { ok: false, error: "Prompt is required" } if text.strip.empty?
 
-      queued_at = Time.now.utc.iso8601(3)
-      @prompt_queue << { prompt: text, queued_at: queued_at }
+      @session_mutex.synchronize do
+        queued_at = Time.now.utc.iso8601(3)
+        @state_mutex.synchronize { @pending_turns += 1 }
+        @prompt_queue << { prompt: text, queued_at: queued_at }
+      end
       broadcast("queue", queue_payload)
       { ok: true, queued: @prompt_queue.size, active: active? }
     end
@@ -103,6 +106,27 @@ module Kward
 
     private
 
+    def new_conversation
+      Conversation.new(
+        workspace_root: @workspace.root.to_s,
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
+        model: (@client.current_model if @client.respond_to?(:current_model)),
+        reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
+      )
+    end
+
+    def build_agent
+      hook_context = lifecycle_hook_context
+      hook_manager = lifecycle_hook_manager
+      Agent.new(
+        client: @client,
+        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
+        conversation: @conversation,
+        hook_manager: hook_manager,
+        hook_context: hook_context
+      )
+    end
+
     def lifecycle_hook_manager
       manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(@workspace.root)).manager
       manager.on_result = method(:broadcast_lifecycle_hook_event)
@@ -185,7 +209,10 @@ module Kward
       broadcast("error", { message: e.message })
       broadcast("turn_finished", queue_payload.merge(status: "failed"))
     ensure
-      set_active(false)
+      @state_mutex.synchronize do
+        @active = false
+        @pending_turns -= 1 if @pending_turns.positive?
+      end
       broadcast("queue", queue_payload)
     end
 
@@ -201,12 +228,18 @@ module Kward
       case [request[:method], request[:path]]
       when ["GET", "/"]
         write_response(socket, 200, { "Content-Type" => "text/html; charset=utf-8" }, render_index)
+      when ["GET", "/kward-logo.png"]
+        write_response(socket, 200, { "Content-Type" => "image/png", "Cache-Control" => "public, max-age=86400" }, File.binread(File.join(__dir__, "kward_logo.png")))
       when ["GET", "/transcript"]
-        write_json(socket, 200, transcript: transcript_items, session: { id: @session.id, path: @session.path }, workspace: @workspace.root.to_s)
+        write_json(socket, 200, transcript: transcript_items, session: active_session_payload, workspace: @workspace.root.to_s)
+      when ["GET", "/sessions"]
+        write_json(socket, 200, sessions: session_payloads, activeSessionId: @session.id)
       when ["GET", "/events"]
         stream_events(socket)
       when ["POST", "/turn"]
-        handle_turn(socket, request[:body])
+        handle_turn(socket, request[:body], request[:headers])
+      when ["POST", "/sessions"]
+        handle_session_action(socket, request[:body], request[:headers])
       else
         write_response(socket, 404, { "Content-Type" => "text/plain; charset=utf-8" }, "Not found\n")
       end
@@ -254,7 +287,9 @@ module Kward
       left.bytes.zip(right.bytes).reduce(0) { |memo, pair| memo | (pair[0] ^ pair[1]) }.zero?
     end
 
-    def handle_turn(socket, body)
+    def handle_turn(socket, body, headers)
+      return write_json(socket, 415, ok: false, error: "Content-Type must be application/json") unless json_request?(headers)
+
       params = JSON.parse(body.empty? ? "{}" : body)
       result = enqueue_prompt(params["prompt"])
       status = result[:ok] ? 202 : 422
@@ -263,6 +298,155 @@ module Kward
       write_json(socket, 400, ok: false, error: "Invalid JSON")
     end
 
+    def handle_session_action(socket, body, headers)
+      return write_json(socket, 415, ok: false, error: "Content-Type must be application/json") unless json_request?(headers)
+
+      params = JSON.parse(body.empty? ? "{}" : body)
+      result = update_session(params)
+      write_json(socket, result.delete(:status), result)
+    rescue JSON::ParserError
+      write_json(socket, 400, ok: false, error: "Invalid JSON")
+    end
+
+    def update_session(params)
+      return { status: 409, ok: false, error: "Wait for queued turns to finish before changing sessions" } if turns_pending?
+
+      result = @session_mutex.synchronize do
+        return { status: 409, ok: false, error: "Wait for queued turns to finish before changing sessions" } if turns_pending?
+
+        case params["action"]
+        when "new" then create_session
+        when "resume" then resume_session(params["id"])
+        when "rename" then rename_session(params["id"], params["name"])
+        when "delete" then delete_session(params["id"])
+        else { status: 422, ok: false, error: "Unknown session action" }
+        end
+      end
+      broadcast("session_changed", result[:session]) if result[:ok] && result[:session]
+      result
+    rescue StandardError => e
+      { status: 422, ok: false, error: e.message }
+    end
+
+    def create_session
+      previous = @session
+      session = @session_store.create(
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
+        model: (@client.current_model if @client.respond_to?(:current_model)),
+        reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
+      )
+      conversation = new_conversation
+      session.attach(conversation)
+      activate_session(session, conversation)
+      previous.delete_if_unused
+      { status: 200, ok: true, session: active_session_payload }
+    end
+
+    def resume_session(id)
+      info = find_session(id)
+      return { status: 404, ok: false, error: "Session not found" } unless info
+      return { status: 200, ok: true, session: active_session_payload } if info.id == @session.id
+
+      previous = @session
+      session, conversation = @session_store.load(
+        info.path,
+        workspace: @workspace,
+        provider: (@client.current_provider if @client.respond_to?(:current_provider)),
+        model: (@client.current_model if @client.respond_to?(:current_model)),
+        reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
+      )
+      activate_session(session, conversation)
+      previous.delete_if_unused
+      { status: 200, ok: true, session: active_session_payload }
+    end
+
+    def rename_session(id, name)
+      clean_name = name.to_s.strip
+      return { status: 422, ok: false, error: "Session name is too long" } if clean_name.length > 120
+
+      target = id.to_s == @session.id ? @session : find_session(id)
+      return { status: 404, ok: false, error: "Session not found" } unless target
+
+      session = target.respond_to?(:rename) ? target : @session_store.load(target.path, workspace: @workspace).first
+      session.rename(clean_name)
+      @session.name = session.name if session.id == @session.id
+      { status: 200, ok: true, session: session_payload(session) }
+    end
+
+    def delete_session(id)
+      if id.to_s == @session.id
+        deleted_id = @session.id
+        deleted_path = @session.path
+        create_session
+        SessionTrash.new.delete(deleted_path)
+        return { status: 200, ok: true, deletedSessionId: deleted_id, session: active_session_payload }
+      end
+
+      info = find_session(id)
+      return { status: 404, ok: false, error: "Session not found" } unless info
+
+      SessionTrash.new.delete(info.path)
+      { status: 200, ok: true, deletedSessionId: info.id }
+    end
+
+    def activate_session(session, conversation)
+      @session = session
+      @conversation = conversation
+      @agent = build_agent
+      @session_store.remember_last_session(session)
+    end
+
+    def find_session(id)
+      session_infos.find { |info| info.id.to_s == id.to_s }
+    end
+
+    def session_infos
+      @session_store.recent(limit: 50, keep_empty_path: @session.path)
+    end
+
+    def session_payloads
+      sessions = session_infos.map { |info| session_payload(info) }
+      sessions.unshift(active_session_payload) unless sessions.any? { |item| item[:id] == @session.id }
+      sessions.sort_by { |item| item[:modifiedAt].to_s }.reverse
+    end
+
+    def active_session_payload
+      info = session_infos.find { |item| item.id == @session.id }
+      return session_payload(info).merge(active: true, path: @session.path) if info
+
+      session_payload(@session).merge(
+        active: true,
+        path: @session.path,
+        modifiedAt: File.mtime(@session.path).utc.iso8601(3),
+        preview: transcript_items.find { |item| item[:role] == "user" }&.fetch(:text, "") || "",
+        messageCount: transcript_items.length
+      )
+    end
+
+    def session_payload(session)
+      name = session.name.to_s.strip
+      preview = session.respond_to?(:first_message) ? session.first_message.to_s : ""
+      {
+        id: session.id,
+        name: name.empty? ? nil : name,
+        title: name.empty? ? (preview.empty? ? "New session" : preview) : name,
+        preview: preview,
+        createdAt: session.created_at&.utc&.iso8601(3),
+        modifiedAt: (session.respond_to?(:modified_at) ? session.modified_at&.utc&.iso8601(3) : nil),
+        messageCount: (session.respond_to?(:message_count) ? session.message_count.to_i : 0),
+        model: (session.respond_to?(:model) ? session.model : @conversation.model),
+        active: session.id == @session.id
+      }
+    end
+
+    def turns_pending?
+      @state_mutex.synchronize { @pending_turns.positive? }
+    end
+
+    def json_request?(headers)
+      headers["content-type"].to_s.downcase.start_with?("application/json")
+    end
+
     def stream_events(socket)
       subscriber = Queue.new
       subscribe(subscriber)
@@ -316,11 +500,38 @@ module Kward
 
     def render_index
       @workspace_root = @workspace.root.to_s
+      @workspace_label = pan_workspace_label
+      @assistant_label = assistant_label
       @session_path = @session.path
+      @version = Kward::VERSION
       template = File.read(File.join(__dir__, "index.html.erb"))
       ERB.new(template).result(binding)
     end
 
+    def assistant_label
+      ConfigFiles.active_persona_label(
+        workspace_root: @conversation.workspace_root,
+        model: @conversation.model,
+        config: @full_config
+      ) || "Assistant"
+    rescue StandardError
+      "Assistant"
+    end
+
+    def pan_workspace_label
+      root = File.expand_path(@workspace.root.to_s)
+      home = Dir.home
+      if root == home || root.start_with?("#{home}/")
+        relative = root.delete_prefix(home).delete_prefix("/")
+        return "~" if relative.empty?
+        return "~/#{relative}" unless relative.include?("/")
+      end
+
+      [File.basename(File.dirname(root)), File.basename(root)].reject(&:empty?).join("/")
+    rescue StandardError
+      @workspace.root.to_s
+    end
+
     def pan_config(config)
       values = config["pan_mode"]
       values.is_a?(Hash) ? values : {}
@@ -332,7 +543,19 @@ module Kward
     end
 
     def display_host
-      @host == "0.0.0.0" ? "<lan-address>" : @host
+      return @host unless @host == "0.0.0.0"
+
+      lan_address || "<lan-address>"
+    end
+
+    def lan_address
+      socket = @udp_socket_class.new
+      socket.connect(ROUTING_PROBE_ADDRESS, ROUTING_PROBE_PORT)
+      socket.addr.last
+    rescue SocketError, SystemCallError
+      nil
+    ensure
+      socket&.close
     end
 
     def set_active(value)
@@ -385,9 +608,9 @@ module Kward
           text.to_s.empty? ? nil : { role: "reasoning", label: "Reasoning", text: text }
         when "text"
           text = part[:text] || part["text"]
-          text.to_s.empty? ? nil : { role: "assistant", label: "Assistant", text: text }
+          text.to_s.empty? ? nil : { role: "assistant", label: assistant_label, text: text }
         when "image"
-          { role: "assistant", label: "Assistant", text: image_part_text(part) }
+          { role: "assistant", label: assistant_label, text: image_part_text(part) }
         when "toolCall"
           { role: "tool", label: "Tool", text: tool_call_part_text(part) }
         end
@@ -442,6 +665,8 @@ module Kward
       when 400 then "Bad Request"
       when 401 then "Unauthorized"
       when 404 then "Not Found"
+      when 409 then "Conflict"
+      when 415 then "Unsupported Media Type"
       when 422 then "Unprocessable Content"
       else "Internal Server Error"
       end

data/lib/kward/permissions/policy.rb

@@ -0,0 +1,171 @@
+require "uri"
+
+# Namespace for Kward's permission-policy runtime.
+module Kward
+  module Permissions
+    # Evaluates the opt-in permission policy for model-requested tool calls.
+    #
+    # The policy is intentionally a decision layer, not a process sandbox. It
+    # can prevent Kward from starting a tool, but it cannot constrain a shell
+    # command after it has begun. OS-enforced sandboxing belongs at a lower
+    # process boundary.
+    class Policy
+      MODES = %w[ask read-only workspace-write deny-by-default].freeze
+      NETWORK_TOOLS = %w[web_search fetch_content fetch_raw].freeze
+      FILE_CHANGE_TOOLS = %w[write_file edit_file].freeze
+
+      Decision = Struct.new(:action, :reason, keyword_init: true) do
+        def allowed?
+          action == :allow
+        end
+
+        def approval_required?
+          action == :ask
+        end
+
+        def denied?
+          action == :deny
+        end
+      end
+
+      def self.from_config(config)
+        permissions = config["permissions"].is_a?(Hash) ? config["permissions"] : {}
+        new(
+          enabled: permissions["enabled"] == true,
+          mode: permissions["mode"],
+          allow: permissions["allow"],
+          ask: permissions["ask"],
+          deny: permissions["deny"],
+          write_scopes: permissions.key?("write_scopes") ? permissions["write_scopes"] : nil
+        )
+      end
+
+      def initialize(enabled: false, mode: "ask", allow: [], ask: [], deny: [], write_scopes: nil)
+        @enabled = enabled == true
+        @mode = normalize_mode(mode)
+        @allow = normalize_rules(allow)
+        @ask = normalize_rules(ask)
+        @deny = normalize_rules(deny)
+        @write_scopes = normalize_scopes(write_scopes)
+        @session_allowed_tools = {}
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      # Allows this model tool for the remaining lifetime of this policy object.
+      # A matching deny or ask rule still takes precedence over this temporary grant.
+      def allow_for_session!(tool_name)
+        @session_allowed_tools[tool_name.to_s] = true
+      end
+
+      def decision_for(tool_name, arguments, source: nil)
+        return Decision.new(action: :allow, reason: "permissions disabled") unless enabled?
+
+        request = request_for(tool_name, arguments, source: source)
+        return Decision.new(action: :deny, reason: "matched deny rule") if matches?(@deny, request)
+        return Decision.new(action: :ask, reason: "matched ask rule") if matches?(@ask, request)
+        return Decision.new(action: :allow, reason: "matched allow rule") if matches?(@allow, request)
+        return Decision.new(action: :allow, reason: "allowed for this session") if @session_allowed_tools[request.fetch("tool")]
+
+        default_decision(request)
+      end
+
+      private
+
+      def normalize_mode(mode)
+        value = mode.to_s
+        MODES.include?(value) ? value : "ask"
+      end
+
+      def normalize_rules(rules)
+        Array(rules).filter_map do |rule|
+          next unless rule.is_a?(Hash)
+
+          rule.transform_keys(&:to_s).slice("tool", "path", "host", "command", "source")
+        end
+      end
+
+      def normalize_scopes(scopes)
+        return nil if scopes.nil?
+
+        Array(scopes).map(&:to_s).reject(&:empty?)
+      end
+
+      def request_for(tool_name, arguments, source:)
+        name = tool_name.to_s
+        args = arguments.to_h
+        {
+          "tool" => name,
+          "path" => args["path"] || args[:path],
+          "host" => request_host(name, args),
+          "command" => args["command"] || args[:command],
+          "source" => source.to_s
+        }.compact.transform_values(&:to_s)
+      end
+
+      def request_host(name, arguments)
+        return nil unless %w[fetch_content fetch_raw].include?(name)
+
+        URI.parse((arguments["url"] || arguments[:url]).to_s).host
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def matches?(rules, request)
+        rules.any? { |rule| rule_matches?(rule, request) }
+      end
+
+      def rule_matches?(rule, request)
+        return false if rule.empty?
+
+        rule.all? do |field, pattern|
+          value = request[field]
+          value && glob_match?(pattern.to_s, value)
+        end
+      end
+
+      def glob_match?(pattern, value)
+        expression = Regexp.escape(pattern).gsub("\\*\\*", ".*").gsub("\\*", "[^/]*")
+        Regexp.new("\\A#{expression}\\z").match?(value)
+      end
+
+      def default_decision(request)
+        return Decision.new(action: :deny, reason: "read-only mode") if @mode == "read-only" && risky?(request)
+        return Decision.new(action: :deny, reason: "deny-by-default mode") if @mode == "deny-by-default" && risky?(request)
+
+        if file_change?(request) && outside_write_scopes?(request)
+          return Decision.new(action: :deny, reason: "path outside write scopes")
+        end
+
+        if @mode == "workspace-write" && file_change?(request)
+          return Decision.new(action: :allow, reason: "workspace write mode")
+        end
+
+        return Decision.new(action: :allow, reason: "read-only tool") unless risky?(request)
+
+        Decision.new(action: :ask, reason: "#{request.fetch("tool")} requires approval")
+      end
+
+      def file_change?(request)
+        FILE_CHANGE_TOOLS.include?(request.fetch("tool"))
+      end
+
+      def network?(request)
+        NETWORK_TOOLS.include?(request.fetch("tool")) || request["source"] == "mcp"
+      end
+
+      def risky?(request)
+        file_change?(request) || request.fetch("tool") == "run_shell_command" || network?(request)
+      end
+
+      def outside_write_scopes?(request)
+        return false if @write_scopes.nil?
+
+        path = request["path"]
+        path.nil? || !@write_scopes.any? { |scope| glob_match?(scope, path) }
+      end
+    end
+  end
+end