kward 0.83.0 → 0.84.0

data/lib/kward/interactive_pty_runner.rb

@@ -3,6 +3,7 @@ require "pty"
 require "timeout"
 require_relative "local_pty_command_runner"
 require_relative "pty_output_sink"
+require_relative "detached_run"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -10,7 +11,7 @@ module Kward
   # This is intentionally low level: UI orchestration decides when terminal
   # ownership is handed to the child process and how the result is presented.
   class InteractivePtyRunner
-    Result = Struct.new(:exit_status, :input_forwarded, keyword_init: true)
+    Result = Struct.new(:exit_status, :input_forwarded, :tab_action, :background, keyword_init: true)
 
     READ_SIZE = 4096
 
@@ -19,28 +20,43 @@ module Kward
       @window_size = nil
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:)
-      pid = nil
+    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:, tab_action_handler: nil, on_detach: nil)
+      reader, writer, pid = PTY.spawn(env.to_h, *command, chdir: cwd.to_s)
       status = nil
-      writer = nil
       input_forwarded = false
-
-      PTY.spawn(env.to_h, *command, chdir: cwd.to_s) do |reader, child_writer, child_pid|
-        pid = child_pid
-        writer = child_writer
-        update_window_size(reader, pid)
-        with_raw_input(input) do
-          input_forwarded = drain_initial_input(input, writer, sink)
-          status, forwarded = forward_io(reader, writer, pid, input, sink)
+      tab_action = nil
+      forwarded = false
+      detached = nil
+
+      update_window_size(reader, pid)
+      with_raw_input(input) do
+        input_forwarded, tab_action = drain_initial_input(input, writer, sink, tab_action_handler: tab_action_handler)
+        if tab_action && on_detach
+          detached_sink = on_detach.call
+          sink.finish if sink.respond_to?(:finish)
+          detached = detach_process(reader, writer, pid, detached_sink, input_forwarded)
+          reader = writer = pid = nil
+        elsif tab_action
+          status = terminate_and_reap(pid)
+        else
+          status, forwarded, tab_action = forward_io(reader, writer, pid, input, sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
           input_forwarded ||= forwarded
+          if tab_action && on_detach
+            detached_sink = on_detach.call
+            sink.finish if sink.respond_to?(:finish)
+            detached = detach_process(reader, writer, pid, detached_sink, input_forwarded)
+            reader = writer = pid = nil
+          end
         end
-        sink.finish if sink.respond_to?(:finish)
-        status ||= wait_for_status(pid)
+        input_forwarded ||= forwarded
       end
+      sink.finish if sink.respond_to?(:finish) && !detached
+      status ||= wait_for_status(pid) if pid
 
-      Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded)
+      Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded, tab_action: tab_action, background: detached)
     ensure
       writer&.close unless writer&.closed?
+      reader&.close unless reader&.closed?
       terminate_and_reap(pid) if pid && status.nil?
     end
 
@@ -60,23 +76,39 @@ module Kward
       yield
     end
 
-    def drain_initial_input(input, writer, sink)
+    def drain_initial_input(input, writer, sink, tab_action_handler: nil)
       forwarded = false
       loop do
         chunk = input.read_nonblock(READ_SIZE, exception: false)
         break if chunk.nil? || chunk == :wait_readable
 
+        filtered = tab_action_handler&.call(chunk)
+        if filtered
+          tab_action = filtered[:tab_action]
+          chunk = filtered[:input].to_s
+          if tab_action
+            unless chunk.empty?
+              sink.input_forwarded if sink.respond_to?(:input_forwarded)
+              writer.write(chunk)
+              writer.flush
+              forwarded = true
+            end
+            return [forwarded, tab_action]
+          end
+        end
+        next if chunk.empty?
+
         sink.input_forwarded if sink.respond_to?(:input_forwarded)
         writer.write(chunk)
         forwarded = true
       end
       writer.flush
-      forwarded
+      [forwarded, nil]
     rescue Errno::EIO, Errno::EPIPE, IOError
-      forwarded
+      [forwarded, nil]
     end
 
-    def forward_io(reader, writer, pid, input, sink)
+    def forward_io(reader, writer, pid, input, sink, tab_action_handler: nil, on_detach: nil)
       input_open = true
       input_forwarded = false
       loop do
@@ -86,19 +118,45 @@ module Kward
         readable = IO.select(readers, nil, nil, 0.02)&.first || []
         forward_pty_output(reader, sink) if readable.include?(reader)
         if input_open && readable.include?(input)
-          input_open, forwarded = forward_input(input, writer, sink)
+          input_open, forwarded, tab_action = forward_input(input, writer, sink, tab_action_handler: tab_action_handler)
           input_forwarded ||= forwarded
+          return [nil, input_forwarded, tab_action] if tab_action && on_detach
+          return [terminate_and_reap(pid), input_forwarded, tab_action] if tab_action
         end
 
         status = finished_status(pid)
         next unless status
 
-        return [finish_stopped_process(pid), input_forwarded] if status.stopped?
+        return [finish_stopped_process(pid), input_forwarded, nil] if status.stopped?
 
         drain_pty_output(reader, sink)
-        return [status, input_forwarded]
+        return [status, input_forwarded, nil]
       rescue Errno::EIO
-        return [wait_for_status(pid), input_forwarded]
+        return [wait_for_status(pid), input_forwarded, nil]
+      end
+    end
+
+    def detach_process(reader, writer, pid, sink, input_forwarded)
+      DetachedRun.new(sink: sink, canceler: -> { terminate_process_group(pid) }) do
+        status = nil
+        begin
+          loop do
+            readable, = IO.select([reader], nil, nil, 0.02)&.first
+            forward_pty_output(reader, sink) if readable
+            status = finished_status(pid)
+            next unless status
+
+            drain_pty_output(reader, sink)
+            break
+          end
+        rescue Errno::EIO
+          status = wait_for_status(pid)
+        ensure
+          sink.finish if sink.respond_to?(:finish)
+          writer.close unless writer.closed?
+          reader.close unless reader.closed?
+        end
+        Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded)
       end
     end
 
@@ -125,17 +183,33 @@ module Kward
       nil
     end
 
-    def forward_input(input, writer, sink)
+    def forward_input(input, writer, sink, tab_action_handler: nil)
       chunk = input.read_nonblock(READ_SIZE, exception: false)
-      return [false, false] if chunk.nil?
-      return [true, false] if chunk == :wait_readable
+      return [false, false, nil] if chunk.nil?
+      return [true, false, nil] if chunk == :wait_readable
+
+      filtered = tab_action_handler&.call(chunk)
+      if filtered
+        tab_action = filtered[:tab_action]
+        chunk = filtered[:input].to_s
+        if tab_action
+          unless chunk.empty?
+            sink.input_forwarded if sink.respond_to?(:input_forwarded)
+            writer.write(chunk)
+            writer.flush
+            return [true, true, tab_action]
+          end
+          return [true, false, tab_action]
+        end
+      end
+      return [true, false, nil] if chunk.empty?
 
       sink.input_forwarded if sink.respond_to?(:input_forwarded)
       writer.write(chunk)
       writer.flush
-      [true, true]
+      [true, true, nil]
     rescue Errno::EIO, Errno::EPIPE, IOError
-      [false, false]
+      [false, false, nil]
     end
 
     def update_window_size(reader, pid)

data/lib/kward/{ekwsh.rb → kwsh.rb}

@@ -10,10 +10,10 @@ end
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Kward-native embedded shell command runner.
-  class Ekwsh
+  class Kwsh
     Result = Struct.new(:output, :exit_status, :exit_shell, :clear, :open_editor_path, :interactive_command, :streamed, keyword_init: true)
     Completion = Struct.new(:range, :replacement, :candidates, keyword_init: true)
-    BUILTINS = %w[alias capture cd pwd export unset unalias clear exit logout pty].freeze
+    BUILTINS = %w[alias capture cd pwd export source unset unalias clear exit logout pty].freeze
     DEFAULT_SHELL = "/bin/sh"
     DEFAULT_TIMEOUT_SECONDS = 300
     DEFAULT_MAX_OUTPUT_BYTES = 1_048_576
@@ -60,7 +60,7 @@ module Kward
     end
 
     # Runs a command for the shell assistant without handing it the terminal.
-    # Built-ins still execute in this Ekwsh instance so their state persists.
+    # Built-ins still execute in this Kwsh instance so their state persists.
     def run_for_agent(input, timeout_seconds: nil, cancellation: nil)
       command = input.to_s.strip
       return run(command, cancellation: cancellation) if command.empty?
@@ -322,12 +322,12 @@ module Kward
       return nil unless %w[exit logout].include?(words.first)
 
       if words.length > 2 || (words[1] && !words[1].match?(/\A\d+\z/))
-        return Result.new(output: "#{command_echo(display_command)}ekwsh: #{words.first}: numeric status expected\n", exit_status: 2)
+        return Result.new(output: "#{command_echo(display_command)}kwsh: #{words.first}: numeric status expected\n", exit_status: 2)
       end
 
       Result.new(output: command_echo(display_command), exit_status: words[1].to_i, exit_shell: true)
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 2)
     end
 
     def builtin_result(command, display_command: command, cancellation: nil, &block)
@@ -347,6 +347,8 @@ module Kward
         print_working_directory(display_command, words)
       when "export"
         export_variables(display_command, words)
+      when "source", "."
+        source_file(display_command, words)
       when "unset"
         unset_variables(display_command, words)
       when "clear"
@@ -359,7 +361,7 @@ module Kward
         nil
       end
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 2)
     end
 
     def captured_command_result(command, display_command:, cancellation: nil, &block)
@@ -399,7 +401,7 @@ module Kward
           invalid << name
         end
       end
-      return Result.new(output: "#{command_echo(command)}ekwsh: alias: invalid name: #{invalid.join(" ")}\n", exit_status: 2) unless invalid.empty?
+      return Result.new(output: "#{command_echo(command)}kwsh: alias: invalid name: #{invalid.join(" ")}\n", exit_status: 2) unless invalid.empty?
 
       names = @aliases.keys.sort if names.empty? && assignments.empty?
       lines = names.filter_map { |name| @aliases[name] ? "alias #{name}=#{Shellwords.escape(@aliases.fetch(name))}" : nil }
@@ -417,7 +419,7 @@ module Kward
       end
 
       missing = words.drop(1).reject { |name| @aliases.delete(name) }
-      return Result.new(output: "#{command_echo(command)}ekwsh: unalias: not found: #{missing.join(" ")}\n", exit_status: 1) unless missing.empty?
+      return Result.new(output: "#{command_echo(command)}kwsh: unalias: not found: #{missing.join(" ")}\n", exit_status: 1) unless missing.empty?
 
       Result.new(output: command_echo(command), exit_status: 0)
     end
@@ -455,7 +457,7 @@ module Kward
       path = File.expand_path(words[2], @cwd)
       Result.new(output: command_echo(display_command), exit_status: 0, open_editor_path: path)
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 2)
     end
 
     def kward_edit_command?(words)
@@ -489,7 +491,7 @@ module Kward
 
     def change_directory(command, words)
       if words.length > 2
-        return Result.new(output: "#{command_echo(command)}ekwsh: cd: too many arguments\n", exit_status: 2)
+        return Result.new(output: "#{command_echo(command)}kwsh: cd: too many arguments\n", exit_status: 2)
       end
 
       target = words[1]
@@ -497,7 +499,7 @@ module Kward
       target = @previous_cwd || @cwd if target == "-"
       path = File.expand_path(target, @cwd)
       unless File.directory?(path)
-        return Result.new(output: "#{command_echo(command)}ekwsh: cd: no such directory: #{target}\n", exit_status: 1)
+        return Result.new(output: "#{command_echo(command)}kwsh: cd: no such directory: #{target}\n", exit_status: 1)
       end
 
       @previous_cwd = @cwd
@@ -528,10 +530,27 @@ module Kward
       if invalid.empty?
         Result.new(output: command_echo(command), exit_status: 0)
       else
-        Result.new(output: "#{command_echo(command)}ekwsh: export: invalid assignment: #{invalid.join(" ")}\n", exit_status: 2)
+        Result.new(output: "#{command_echo(command)}kwsh: export: invalid assignment: #{invalid.join(" ")}\n", exit_status: 2)
       end
     end
 
+    def source_file(command, words)
+      unless words.length == 2
+        return Result.new(output: "#{command_echo(command)}Usage: source <file>\n", exit_status: 2)
+      end
+
+      require_relative "kwshrc"
+      path = Kwshrc.resolve_path(words[1], cwd: @cwd, env: @env)
+      config = Kwshrc.read_file(path, env: @env)
+      path_changed = config[:env].key?("PATH")
+      @env.merge!(config[:env])
+      @aliases.merge!(config[:aliases])
+      invalidate_path_executables_cache if path_changed
+      Result.new(output: command_echo(command), exit_status: 0)
+    rescue Kwshrc::ParseError => e
+      Result.new(output: "#{command_echo(command)}kwsh: source: #{e.message}\n", exit_status: 1)
+    end
+
     def unset_variables(command, words)
       names = words.drop(1)
       names.shift if names.first == "--"
@@ -541,7 +560,7 @@ module Kward
       if invalid.empty?
         Result.new(output: command_echo(command), exit_status: 0)
       else
-        Result.new(output: "#{command_echo(command)}ekwsh: unset: invalid name: #{invalid.join(" ")}\n", exit_status: 2)
+        Result.new(output: "#{command_echo(command)}kwsh: unset: invalid name: #{invalid.join(" ")}\n", exit_status: 2)
       end
     end
 
@@ -575,8 +594,8 @@ module Kward
       end
       append_output_newline(output) { |text| yield text if streamed }
       exit_status = result.timed_out || result.truncated ? 1 : (result.exit_status || 1)
-      append_streamed(output, "ekwsh: command timed out after #{timeout} seconds\n", streamed) { |text| yield text } if result.timed_out
-      append_streamed(output, "ekwsh: output exceeded #{@max_output_bytes} bytes; command terminated\n", streamed) { |text| yield text } if result.truncated
+      append_streamed(output, "kwsh: command timed out after #{timeout} seconds\n", streamed) { |text| yield text } if result.timed_out
+      append_streamed(output, "kwsh: output exceeded #{@max_output_bytes} bytes; command terminated\n", streamed) { |text| yield text } if result.truncated
       append_streamed(output, "Exit status: #{exit_status}\n", streamed) { |text| yield text } unless exit_status.zero?
       Result.new(output: output, exit_status: exit_status, streamed: streamed)
     rescue Cancellation::CancelledError
@@ -584,7 +603,7 @@ module Kward
       append_streamed(output, "^C\nExit status: 130\n", streamed) { |text| yield text }
       Result.new(output: output, exit_status: 130, streamed: streamed)
     rescue Errno::ENOENT => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 127)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 127)
     end
 
     def effective_timeout(timeout_seconds)

data/lib/kward/kwshrc.rb

@@ -0,0 +1,233 @@
+require "shellwords"
+require_relative "kwsh"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Parses the declarative subset of a shell startup file used by kwsh.
+  #
+  # Only aliases, exports, and source directives are handled. Other shell
+  # syntax is intentionally ignored until kwsh supports scripting.
+  class Kwshrc
+    VARIABLE_NAME = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    VARIABLE_PATTERN = /[A-Za-z_][A-Za-z0-9_]*/
+
+    class ParseError < StandardError
+    end
+
+    def self.read(paths, env: ENV.to_h)
+      new(env: env).read(paths)
+    end
+
+    def self.read_file(path, env: ENV.to_h)
+      parser = new(env: env)
+      parser.read_path(path)
+    end
+
+    def self.resolve_path(path, cwd:, env: ENV.to_h)
+      parser = new(env: env)
+      expanded = parser.send(:expand_variables, path.to_s)
+      expanded = expanded.sub(/\A~(?=\/|\z)/, Dir.home)
+      File.expand_path(expanded, cwd)
+    end
+
+    def initialize(env: ENV.to_h)
+      @environment = env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
+      @exports = {}
+      @aliases = {}
+      @loading = []
+    end
+
+    def read(paths)
+      Array(paths).each { |path| read_file(path, required: false) }
+      configuration
+    end
+
+    def read_path(path)
+      read_file(path, required: true)
+      configuration
+    end
+
+    private
+
+    def configuration
+      { env: @exports, aliases: @aliases }
+    end
+
+    def read_file(path, required:)
+      path = File.expand_path(path.to_s)
+      unless File.file?(path)
+        raise ParseError, "#{path}: file not found" if required
+        return
+      end
+      raise ParseError, "#{path}: recursive source" if @loading.include?(path)
+
+      @loading << path
+      File.foreach(path).with_index(1) do |line, line_number|
+        parse_line(strip_comment(line).strip, path, line_number)
+      end
+    rescue Errno::EACCES, Errno::EISDIR, Errno::ENOENT => e
+      raise ParseError, "#{path}: #{e.message}"
+    ensure
+      @loading.delete(path)
+    end
+
+    def parse_line(line, path, line_number)
+      return if line.empty?
+
+      words = Shellwords.split(line)
+      return if words.empty?
+
+      case words.shift
+      when "alias"
+        parse_aliases(words)
+      when "export"
+        parse_exports(expand_variables(line), path, line_number)
+      when "source", "."
+        parse_source(expand_variables(line), path, line_number)
+      end
+    rescue ArgumentError => e
+      raise ParseError, "#{path}:#{line_number}: #{e.message}"
+    end
+
+    def parse_aliases(words)
+      words.each do |assignment|
+        name, command = assignment.split("=", 2)
+        next unless command && Kwsh.valid_alias_name?(name)
+        next if command.empty?
+
+        @aliases[name] = command
+      end
+    end
+
+    def parse_exports(line, path, line_number)
+      words = Shellwords.split(line)
+      assignments = words.drop(1)
+      raise ParseError, "#{path}:#{line_number}: export requires a variable" if assignments.empty?
+
+      assignments.each do |assignment|
+        name, value = assignment.split("=", 2)
+        next unless name.match?(VARIABLE_NAME)
+
+        value = @environment[name] if value.nil? && @environment.key?(name)
+        next if value.nil?
+
+        @environment[name] = value
+        @exports[name] = value
+      end
+    rescue ArgumentError => e
+      raise ParseError, "#{path}:#{line_number}: #{e.message}"
+    end
+
+    def parse_source(line, path, line_number)
+      words = Shellwords.split(line)
+      source_path = words[1]
+      if words.length != 2 || source_path.to_s.empty?
+        raise ParseError, "#{path}:#{line_number}: source requires one file"
+      end
+
+      source_path = File.expand_path(source_path, File.dirname(path))
+      read_file(source_path, required: true)
+    rescue ArgumentError => e
+      raise ParseError, "#{path}:#{line_number}: #{e.message}"
+    end
+
+    def strip_comment(line)
+      result = +""
+      quote = nil
+      escaped = false
+
+      line.each_char do |character|
+        if escaped
+          result << character
+          escaped = false
+        elsif character == "\\" && quote != "'"
+          result << character
+          escaped = true
+        elsif quote
+          result << character
+          quote = nil if character == quote
+        elsif character == "'" || character == '"'
+          result << character
+          quote = character
+        elsif character == "#"
+          break
+        else
+          result << character
+        end
+      end
+      result
+    end
+
+    def expand_variables(text)
+      result = +""
+      quote = nil
+      escaped = false
+      index = 0
+
+      while index < text.length
+        character = text[index]
+        if escaped
+          result << character
+          escaped = false
+          index += 1
+          next
+        end
+        if character == "\\" && quote != "'"
+          result << character
+          escaped = true
+          index += 1
+          next
+        end
+        if character == "'"
+          quote = if quote == "'"
+            nil
+          elsif quote.nil?
+            character
+          else
+            quote
+          end
+          result << character
+          index += 1
+          next
+        end
+        if character == '"'
+          quote = if quote == '"'
+            nil
+          elsif quote.nil?
+            character
+          else
+            quote
+          end
+          result << character
+          index += 1
+          next
+        end
+
+        if character == "$" && quote != "'"
+          name, length = variable_at(text, index)
+          if name
+            result << @environment.fetch(name, "")
+            index += length
+            next
+          end
+        end
+
+        result << character
+        index += 1
+      end
+      result
+    end
+
+    def variable_at(text, index)
+      if text[index + 1] == "{"
+        closing = text.index("}", index + 2)
+        name = text[(index + 2)...closing] if closing
+        return [name, closing - index + 1] if name&.match?(VARIABLE_NAME)
+      else
+        match = text[(index + 1)..].match(/\A#{VARIABLE_PATTERN}/)
+        return [match[0], match[0].length + 1] if match
+      end
+      nil
+    end
+  end
+end