samagotchi 0.2.0

data/lib/samagotchi/tools/task_runtime.rb

@@ -0,0 +1,311 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+require "securerandom"
+require "shellwords"
+require "time"
+
+module Samagotchi
+  module Tools
+    module TaskRuntime
+      TASKS_DIR = File.join("tmp", "tasks")
+      METADATA_FILENAME = "task.json"
+      OUTPUT_FILENAME = "output.log"
+      EXIT_CODE_FILENAME = "exit_code"
+      STOP_GRACE_SEC = 3.0
+      STOP_POLL_INTERVAL_SEC = 0.1
+      METADATA_VERSION = 1
+      OUTPUT_TAIL_READ_BYTES = 16 * 1024
+      SANITIZED_ENV_KEYS = %w[RUBYOPT RUBYLIB BUNDLE_GEMFILE BUNDLE_BIN_PATH BUNDLER_VERSION].freeze
+
+      module_function
+
+      def create_task(command, cwd: nil, env: nil)
+        normalized_command = command.to_s.strip
+        return [nil, "Error: command is required"] if normalized_command.empty?
+
+        resolved_cwd = normalize_cwd(cwd)
+        return [nil, "Error: cwd not found: #{resolved_cwd}"] unless Dir.exist?(resolved_cwd)
+
+        spawn_env, env_error = spawn_env_for(env)
+        return [nil, env_error] if env_error
+
+        task_id = generate_task_id
+        task_dir = task_dir_for(task_id)
+        output_path = File.join(task_dir, OUTPUT_FILENAME)
+        exit_code_path = File.join(task_dir, EXIT_CODE_FILENAME)
+
+        FileUtils.mkdir_p(task_dir)
+
+        output_io = File.open(output_path, "a")
+        output_io.sync = true
+
+        wrapped_command = wrapped_shell_command(normalized_command, exit_code_path)
+        # Non-login shell (matches Execute): a login shell re-sources profile
+        # files, which can rebuild PATH and shadow the inherited toolchain.
+        pid = Process.spawn(
+          spawn_env,
+          "/bin/sh", "-c", wrapped_command,
+          chdir: resolved_cwd,
+          out: output_io,
+          err: output_io,
+          pgroup: true
+        )
+        Process.detach(pid)
+
+        now = timestamp
+        record = {
+          "metadata_version" => METADATA_VERSION,
+          "id" => task_id,
+          "command" => normalized_command,
+          "cwd" => resolved_cwd,
+          "workspace_root" => Dir.pwd,
+          "status" => "running",
+          "pid" => pid,
+          "created_at" => now,
+          "started_at" => now,
+          "finished_at" => nil,
+          "exit_code" => nil,
+          "stop_reason" => nil,
+          "output_path" => output_path,
+          "exit_code_path" => exit_code_path
+        }
+
+        write_record(record)
+        [record, nil]
+      rescue => e
+        [nil, "Error: #{e.message}"]
+      ensure
+        output_io&.close
+      end
+
+      def list_records
+        ensure_tasks_dir
+        task_dirs = Dir.glob(File.join(TASKS_DIR, "*"))
+                       .select { |path| File.directory?(path) }
+
+        task_dirs.map do |task_dir|
+          id = File.basename(task_dir)
+          record = load_record(id)
+          next nil unless record
+
+          refresh_record(record)
+        end.compact.sort_by { |record| record["created_at"].to_s }.reverse
+      end
+
+      def get_record(task_id)
+        record = load_record(task_id)
+        return [nil, "Error: task not found: #{task_id}"] unless record
+
+        [refresh_record(record), nil]
+      rescue => e
+        [nil, "Error: #{e.message}"]
+      end
+
+      def output_tail_lines(path, line_count)
+        return "" unless File.file?(path)
+
+        size = File.size(path)
+        offset = [size - OUTPUT_TAIL_READ_BYTES, 0].max
+        content = File.open(path, "rb") do |file|
+          file.seek(offset)
+          file.read
+        end
+        content = content.split("\n", 2).last.to_s if offset.positive?
+        content.lines.last(line_count).join
+      end
+
+      def stop_task(task_id)
+        record = load_record(task_id)
+        return [nil, "Error: task not found: #{task_id}"] unless record
+
+        refreshed = refresh_record(record)
+        return [refreshed, nil] unless refreshed["status"] == "running"
+
+        pid = refreshed["pid"].to_i
+
+        begin
+          Process.kill("TERM", -pid)
+        rescue Errno::ESRCH
+          # Process already exited; status refresh below handles final state.
+        end
+
+        deadline = monotonic_time + STOP_GRACE_SEC
+        while process_alive?(pid) && monotonic_time < deadline
+          sleep(STOP_POLL_INTERVAL_SEC)
+        end
+
+        if process_alive?(pid)
+          begin
+            Process.kill("KILL", -pid)
+          rescue Errno::ESRCH
+            # Process exited between checks.
+          end
+        end
+
+        updated = refresh_record(refreshed)
+        updated["status"] = "stopped" if updated["status"] == "running"
+        updated["finished_at"] ||= timestamp
+        updated["stop_reason"] = "stopped_by_user"
+        write_record(updated)
+
+        [updated, nil]
+      rescue => e
+        [nil, "Error: #{e.message}"]
+      end
+
+      def refresh_record(record)
+        return record unless record["status"] == "running"
+
+        pid = record["pid"].to_i
+        return mark_finished_without_exit_code(record) unless process_alive?(pid)
+
+        record
+      end
+
+      def load_record(task_id)
+        path = metadata_path(task_id)
+        return nil unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def write_record(record)
+        ensure_tasks_dir
+        dir = task_dir_for(record.fetch("id"))
+        FileUtils.mkdir_p(dir)
+
+        path = File.join(dir, METADATA_FILENAME)
+        temp_path = "#{path}.tmp"
+        File.write(temp_path, JSON.pretty_generate(record) + "\n")
+        File.rename(temp_path, path)
+      end
+
+      def metadata_path(task_id)
+        File.join(task_dir_for(task_id), METADATA_FILENAME)
+      end
+
+      def task_dir_for(task_id)
+        File.join(TASKS_DIR, task_id.to_s)
+      end
+
+      def ensure_tasks_dir
+        FileUtils.mkdir_p(TASKS_DIR)
+      end
+
+      def generate_task_id
+        loop do
+          candidate = "#{Time.now.utc.strftime("%Y%m%d%H%M%S")}-#{SecureRandom.hex(4)}"
+          return candidate unless File.exist?(metadata_path(candidate))
+        end
+      end
+
+      def normalize_cwd(cwd)
+        value = cwd.to_s.strip
+        value.empty? ? Dir.pwd : File.expand_path(value)
+      end
+
+      def wrapped_shell_command(command, exit_code_path)
+        escaped_exit_code_path = Shellwords.escape(exit_code_path)
+        <<~SH
+          #{command}
+          status=$?
+          printf "%s" "$status" > #{escaped_exit_code_path}
+          exit "$status"
+        SH
+      end
+
+      def sanitized_spawn_env
+        # Running from temporary directories can inherit Bundler-specific env
+        # (for example RUBYOPT=-rbundler/setup) that breaks plain `ruby -e`.
+        {
+          "RUBYOPT" => sanitized_rubyopt,
+          "RUBYLIB" => nil,
+          "BUNDLE_GEMFILE" => nil,
+          "BUNDLE_BIN_PATH" => nil,
+          "BUNDLER_VERSION" => nil
+        }
+      end
+
+      def spawn_env_for(overrides)
+        return [sanitized_spawn_env, nil] if overrides.nil? || overrides.to_s.empty?
+
+        overrides = JSON.parse(overrides) if overrides.is_a?(String)
+        return [nil, "Error: env must be an object"] unless overrides.is_a?(Hash)
+
+        normalized = {}
+        overrides.each do |key, value|
+          return [nil, "Error: env keys and values must be strings"] unless key.is_a?(String) && value.is_a?(String)
+          return [nil, "Error: env keys and values cannot contain NUL bytes"] if key.include?("\0") || value.include?("\0")
+          return [nil, "Error: env key is reserved: #{key}"] if SANITIZED_ENV_KEYS.include?(key)
+
+          normalized[key] = value
+        end
+
+        [sanitized_spawn_env.merge(normalized), nil]
+      rescue JSON::ParserError
+        [nil, "Error: env must be a JSON object"]
+      end
+
+      def sanitized_rubyopt
+        rubyopt = ENV["RUBYOPT"].to_s
+        return nil if rubyopt.empty?
+
+        filtered = rubyopt.split(/\s+/).reject do |arg|
+          arg == "-rbundler/setup" || arg.match?(/\A-r.*bundler\/setup\z/)
+        end
+        return nil if filtered.empty?
+
+        filtered.join(" ")
+      end
+
+      def process_alive?(pid)
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
+
+      def mark_finished_without_exit_code(record)
+        exit_code = read_exit_code(record["exit_code_path"])
+
+        if exit_code.nil?
+          record["status"] = "failed"
+          record["exit_code"] = nil
+          record["stop_reason"] ||= "process_ended_without_exit_code"
+        elsif exit_code.zero?
+          record["status"] = "completed"
+          record["exit_code"] = 0
+        else
+          record["status"] = "failed"
+          record["exit_code"] = exit_code
+        end
+
+        record["finished_at"] ||= timestamp
+        write_record(record)
+        record
+      end
+
+      def read_exit_code(path)
+        return nil if path.to_s.empty? || !File.exist?(path)
+
+        Integer(File.read(path).strip, exception: false)
+      rescue => _e
+        nil
+      end
+
+      def timestamp
+        Time.now.utc.iso8601
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/task_stop.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "task_runtime"
+
+module Samagotchi
+  module Tools
+    class TaskStop
+      NAME = "task_stop"
+
+      def self.name = NAME
+
+      def self.call(task_id)
+        record, error = TaskRuntime.stop_task(task_id.to_s.strip)
+        return error if error
+
+        [
+          "task_id: #{record.fetch("id")}",
+          "status: #{record.fetch("status")}",
+          "exit_code: #{record["exit_code"]}",
+          "finished_at: #{record["finished_at"]}",
+          "stop_reason: #{record["stop_reason"]}",
+          "output_path: #{record.fetch("output_path")}"
+        ].join("\n")
+      rescue => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/task_wait.rb

@@ -0,0 +1,104 @@
+
+# frozen_string_literal: true
+
+require_relative "task_runtime"
+
+module Samagotchi
+  module Tools
+    class TaskWait
+      NAME = "task_wait"
+      TIMEOUT_DEFAULT = 600
+      TAIL_LINES_DEFAULT = 10
+      TAIL_LINES_MAX = 100
+      POLL_INTERVAL = 0.5
+
+      def self.name = NAME
+
+      def self.call(task_id, timeout: TIMEOUT_DEFAULT, tail_lines: TAIL_LINES_DEFAULT, done_pattern: nil)
+        timeout = TIMEOUT_DEFAULT if blank?(timeout)
+        tail_lines = TAIL_LINES_DEFAULT if blank?(tail_lines)
+        timeout = timeout.to_i
+        return "Error: task_id is required" if task_id.to_s.strip.empty?
+
+        tail_lines = parse_tail_lines(tail_lines)
+        return tail_lines if tail_lines.is_a?(String)
+
+        completion_pattern = parse_done_pattern(done_pattern)
+        return completion_pattern if completion_pattern.is_a?(String)
+
+        task_id = task_id.to_s.strip
+        deadline = monotonic_time + timeout
+
+        loop do
+          record, error = TaskRuntime.get_record(task_id)
+          return "Error: #{error}" if error
+
+          status = record.fetch("status")
+          return format_response(record) unless status == "running"
+
+          if completion_pattern
+            output_tail = TaskRuntime.output_tail_lines(record.fetch("output_path"), tail_lines)
+            return format_response(record, wait_result: "pattern_matched", output_tail: output_tail) if completion_pattern.match?(output_tail)
+          end
+
+          break if monotonic_time > deadline
+          sleep(POLL_INTERVAL)
+        end
+
+        # Timeout reached — do one final refresh to capture the latest status
+        refreshed, _ = TaskRuntime.get_record(task_id)
+        return format_response(refreshed) unless refreshed.fetch("status") == "running"
+
+        output_tail = TaskRuntime.output_tail_lines(refreshed.fetch("output_path"), tail_lines)
+        format_response(refreshed, wait_result: "timeout", output_tail: output_tail)
+      rescue => e
+        "Error: #{e.message}"
+      end
+
+      def self.format_response(record, wait_result: nil, output_tail: nil)
+        lines = [
+          "task_id: #{record.fetch("id")}",
+          "status: #{record.fetch("status")}",
+          "exit_code: #{record["exit_code"]}",
+          "stop_reason: #{record["stop_reason"]}",
+          "output_path: #{record.fetch("output_path")}"
+        ]
+        return lines.join("\n") unless wait_result
+
+        lines << "wait_result: #{wait_result}"
+        lines << "output_tail:"
+        lines << output_tail.rstrip unless output_tail.empty?
+        lines.join("\n")
+      end
+      private_class_method :format_response
+
+      def self.parse_tail_lines(value)
+        parsed = Integer(value, exception: false)
+        return "Error: tail_lines must be a positive integer" unless parsed&.positive?
+        return "Error: tail_lines must be at most #{TAIL_LINES_MAX}" if parsed > TAIL_LINES_MAX
+
+        parsed
+      end
+      private_class_method :parse_tail_lines
+
+      def self.parse_done_pattern(value)
+        return nil if blank?(value)
+
+        Regexp.new(value.to_s)
+      rescue RegexpError => e
+        "Error: invalid done_pattern: #{e.message}"
+      end
+      private_class_method :parse_done_pattern
+
+      def self.blank?(value)
+        value.nil? || value.to_s.strip.empty?
+      end
+      private_class_method :blank?
+
+      def self.monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end
+

data/lib/samagotchi/tools/tool_path.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Samagotchi
+  module Tools
+    # Normalizes a path argument sent by the model: strips surrounding
+    # whitespace and expands a leading `~` (Ruby's File APIs treat it
+    # literally, which used to create a `./~/` directory in the cwd).
+    # Other paths are returned as-is so relative paths stay relative.
+    module ToolPath
+      module_function
+
+      def normalize(path)
+        path = path.to_s.strip
+        path.start_with?("~") ? File.expand_path(path) : path
+      end
+    end
+  end
+end

data/lib/samagotchi/tools/web_fetch.rb

@@ -0,0 +1,163 @@
+
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "ipaddr"
+require "nokogiri"
+require_relative "../version"
+
+module Samagotchi
+  module Tools
+    # Fetches the content of a URL and returns cleaned text content.
+    class WebFetch
+      NAME        = "web_fetch"
+      TIMEOUT_SEC = 15
+      MAX_OUTPUT_BYTES = 32 * 1024
+
+      def self.name        = NAME
+
+      def self.call(url)
+        url = url.to_s.strip
+        return "Error: URL is required" if url.empty?
+
+        uri = URI.parse(url)
+        unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+          return "Error: invalid URL scheme. Expected http:// or https://"
+        end
+
+        return "Error: SSRF protection blocked access to internal/private host" unless ssrf_protected?(uri)
+
+        response = fetch_url(uri)
+        return handle_http_error(response, uri) unless response.is_a?(Net::HTTPSuccess)
+
+        content_type = response["content-type"] || ""
+        return to_utf8(extract_text_from_html(response.body)) if content_type.include?("text/html")
+        return to_utf8(response.body) if content_type.include?("text/")
+
+        "Error: unsupported content type: #{content_type}"
+      rescue URI::InvalidURIError
+        "Error: invalid URI format"
+      rescue SocketError
+        "Error: could not resolve hostname"
+      rescue Timeout::Error
+        "Error: request timed out after #{TIMEOUT_SEC}s"
+      rescue => e
+        "Error: #{e.message}"
+      end
+
+      def self.ssrf_protected?(uri)
+        return true if uri.host.nil?
+
+        private_ranges = [
+          IPAddr.new("127.0.0.0/8"),
+          IPAddr.new("10.0.0.0/8"),
+          IPAddr.new("172.16.0.0/12"),
+          IPAddr.new("192.168.0.0/16"),
+          IPAddr.new("169.254.0.0/16"),
+          IPAddr.new("0.0.0.0/8"),
+          IPAddr.new("::1/128"),
+          IPAddr.new("fc00::/7"),
+          IPAddr.new("fe80::/10"),
+          IPAddr.new("::ffff:0:0/96"),
+        ]
+
+        # Try to parse host as IP directly
+        begin
+          ip = IPAddr.new(uri.host)
+          private_ranges.each { |range| return false if range.include?(ip) }
+          return true
+        rescue IPAddr::InvalidAddressError
+          # Host is a domain name — resolve and check
+        end
+
+        # Resolve domain to IP and check
+        begin
+          addr_info = Socket.getaddrinfo(uri.host, 80, :INET, :STREAM)
+          ip = addr_info.first[3]
+          private_ranges.each { |range| return false if range.include?(ip) }
+        rescue SocketError
+          # DNS failure — let fetch URL handle it
+        end
+
+        true
+      end
+
+      def self.fetch_url(uri)
+        Net::HTTP.start(uri.host, uri.port,
+                        use_ssl: uri.scheme == "https",
+                        open_timeout: TIMEOUT_SEC,
+                        read_timeout: TIMEOUT_SEC) do |http|
+          request = Net::HTTP::Get.new(uri.request_uri)
+          request["User-Agent"] = Samagotchi::USER_AGENT
+          http.request(request)
+        end
+      end
+
+      def self.handle_http_error(response, uri)
+        case response
+        when Net::HTTPNotFound
+          "Error: 404 Not Found for #{uri}"
+        when Net::HTTPForbidden
+          "Error: 403 Forbidden for #{uri}"
+        when Net::HTTPUnauthorized
+          "Error: 401 Unauthorized for #{uri}"
+        when Net::HTTPGatewayTimeout, Net::HTTPBadGateway
+          "Error: server error (#{response.code}) for #{uri}"
+        else
+          "Error: HTTP #{response.code} for #{uri}"
+        end
+      end
+
+      # Network bodies come back tagged ASCII-8BIT even when they hold UTF-8
+      # bytes (web text is essentially always UTF-8). Relabel as UTF-8 so the
+      # result can be safely interpolated into UTF-8 strings (logs, conversation
+      # history) without raising
+      # "incompatible character encodings: UTF-8 and BINARY (ASCII-8BIT)".
+      # Falls back to lossy replacement only if the bytes are genuinely not
+      # valid UTF-8.
+      def self.to_utf8(str)
+        s = str.to_s
+        return s if s.encoding == Encoding::UTF_8 && s.valid_encoding?
+
+        s = s.dup.force_encoding(Encoding::UTF_8)
+        return s if s.valid_encoding?
+
+        s.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+      end
+
+      def self.extract_text_from_html(html)
+        return "Error: empty HTML response" if html.nil? || html.empty?
+
+        doc = Nokogiri::HTML(html)
+
+        # Extract noscript text before removing it
+        doc.css("noscript").each do |node|
+          node.replace(node.text) if node.text?
+        end
+
+        # Remove script, style, iframe, svg elements
+        doc.css("script, style, iframe, svg").remove
+
+        # Get text content
+        text = doc.text
+        text = text.gsub(/\s+/, " ").strip
+        text = text.gsub(/\n\s*\n/, "\n\n").strip
+
+        return "Error: no visible text content found in HTML" if text.empty?
+
+        # Truncate to max output bytes
+        if text.bytesize > MAX_OUTPUT_BYTES
+          suffix = "... [TRUNCATED - content too large]"
+          budget = MAX_OUTPUT_BYTES - suffix.bytesize
+          truncated = text.byteslice(0, budget)
+          truncated = truncated.encode("UTF-8", invalid: :replace, undef: :replace)
+          text = "#{truncated}#{suffix}"
+        end
+
+        text
+      end
+    end
+  end
+end
+

data/lib/samagotchi/tools/write.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "tool_path"
+
+module Samagotchi
+  module Tools
+    # Writes content to a file, creating parent directories as needed.
+    # The path is passed as an XML attribute:
+    #   <tool name="write" path="lib/samagotchi/tools/new_tool.rb">content</tool>
+    class Write
+      NAME        = "write"
+
+      def self.name        = NAME
+
+      def self.call(content, path:)
+        path = ToolPath.normalize(path)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+        "Written #{content.bytesize} bytes to #{path}"
+      rescue => e
+        "Error: #{e.message}"
+      end
+    end
+  end
+end