openclacky 1.5.19 → 1.5.21

data/lib/clacky/tools/terminal.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "pty"
+require "tempfile"
+require "shellwords"
 require "securerandom"
 require "fileutils"
 require_relative "base"
@@ -73,9 +75,6 @@ module Clacky
           {session_id, input:"pw\n"}      reply to prompt / poll (input:"")
           {session_id, kill:true}         stop
 
-        Single-line only. For multi-line scripts (heredoc, loops, multi-statement blocks)
-        write a file first, then run it: write(path:"/tmp/run.sh", content:...) → terminal(command:"bash /tmp/run.sh").
-
         Response: exit_code = done; session_id = running (state: waiting/background/timeout).
         If output exceeds the limit, `output` is truncated and `full_output_file` points
         at a file on disk — use terminal(command: "grep ... <path>") to search it.
@@ -133,6 +132,7 @@ module Clacky
       BACKGROUND_COLLECT_SECONDS = 2
       # Sentinel: when passed as idle_ms, disables idle early-return.
       DISABLED_IDLE_MS = 10_000_000
+      PTY_COLS = 120
       # Gap between log-file polls while waiting for a command's end marker.
       MARKER_POLL_SECONDS = 0.05
       # A freshly spawned login shell prints its banner asynchronously; wait
@@ -244,17 +244,6 @@ module Clacky
 
         # Start a new command
         if command && !command.to_s.strip.empty?
-          if multiline_command?(command)
-            return {
-              error: "Multi-line commands are unreliable in our PTY shell " \
-                     "(heredocs / unclosed quotes / multi-line blocks can hang the session).",
-              hint: "Write the script to a file first, then execute it. " \
-                    "Example: 1) write(path: \"/tmp/run.sh\", content: \"...\")  " \
-                    "2) terminal(command: \"bash /tmp/run.sh\")",
-              multiline_blocked: true
-            }
-          end
-
           return do_start(command.to_s, cwd: cwd, env: env, timeout: timeout,
                           idle_ms: idle_ms, background: background ? true : false,
                           on_output: on_output)
@@ -402,6 +391,43 @@ module Clacky
         )
       end
 
+      SCRIPT_DIR = "/tmp/.clacky"
+      private def prepare_execution_command(session, command)
+        return command unless multiline_command?(command)
+
+        prepare_multiline_command(session, command)
+      end
+
+      # Keep script contents out of the interactive PTY input parser.
+      private def prepare_multiline_command(session, command)
+        session.script_paths.delete_if { |path| !File.exist?(path) }
+
+        script_dir = File.join(SCRIPT_DIR, session.id.to_s)
+        [SCRIPT_DIR, script_dir].each do |path|
+          FileUtils.mkdir_p(path, mode: 0700)
+          directory = File.lstat(path)
+          unless directory.directory? && directory.uid == Process.uid && (directory.mode & 0077).zero?
+            raise IOError, "#{path} must be a private directory owned by the current user"
+          end
+        end
+
+        file = Tempfile.create(["script-", ".sh"], script_dir)
+        session.script_paths << file.path
+        begin
+          file.write(command)
+          file.write("\n") unless command.end_with?("\n")
+        ensure
+          file.close
+        end
+        "( . #{Shellwords.escape(file.path)} )"
+      end
+
+      private def hide_script_paths(session, output)
+        Array(session.script_paths).reduce(output) do |text, path|
+          text.gsub(/#{Regexp.escape(path)}(?:: ?)?/, "")
+        end
+      end
+
       # ---------------------------------------------------------------------
       # 2) Continue / poll an existing session
       # ---------------------------------------------------------------------
@@ -475,11 +501,12 @@ module Clacky
         raw = read_log_slice(session.log_file, start_offset, new_offset)
         cleaned = OutputCleaner.clean(raw)
         cleaned = cleaned.sub(session.marker_regex, "").rstrip if session.marker_regex
-        cleaned = strip_command_echo(cleaned, marker_token: session.marker_token)
+        cleaned = strip_command_echo(cleaned, marker_token: session.marker_token, echo_head: session.echo_head)
         # Per-line cap first: one minified JSON blob shouldn't blow the
         # whole 4 KB budget. MUST run before overflow spill so the file
         # on disk also has the long lines shortened (otherwise grep-ing
         # the spill file returns thousand-char lines the LLM chokes on).
+        cleaned = hide_script_paths(session, cleaned)
         cleaned = truncate_long_lines(cleaned)
         truncated = false
         overflow_file = nil
@@ -516,6 +543,7 @@ module Clacky
 
         case state
         when :matched, :eof
+          SessionManager.cleanup_scripts(session)
           exit_code = code || session.exit_code
           if persistent && state == :matched && session_healthy?(session)
             # Command finished cleanly — return the shell to the pool so
@@ -611,7 +639,7 @@ module Clacky
       #     safe: the real completion marker was already removed via
       #     session.marker_regex above, so any surviving occurrence of
       #     __CLACKY_DONE_<token>_ is by definition an echoed wrapper.
-      private def strip_command_echo(text, marker_token: nil)
+      private def strip_command_echo(text, marker_token: nil, echo_head: nil)
         return text if text.nil? || text.empty?
 
         # Pass 0: strip the hooks prefix echo if `stty -echo` failed and
@@ -641,6 +669,16 @@ module Clacky
           text = text.sub(/\A\{[^\n]*\n/, "")
         end
 
+        # Pass 1b: a wrapped `{ CMD` echo leaves its last screen row as a bare command suffix above the tail.
+        if echo_head && echo_head.bytesize > PTY_COLS
+          lines = text.lines
+          text = lines.reject.with_index do |ln, i|
+            body = ln.chomp
+            !body.empty? && body.size < echo_head.size && echo_head.end_with?(body) &&
+              lines[i + 1].to_s.match?(/\A\}[^\n;]*; *__clacky_ec=\$\?/)
+          end.join
+        end
+
         # Pass 2: token-aware global strip — remove any leftover wrapper
         # echo fragment, wherever it sits. Requires the session token so
         # we never touch unrelated user output that happens to mention
@@ -881,7 +919,7 @@ module Clacky
         end
 
         begin
-          writer.winsize = [40, 120]
+          writer.winsize = [40, PTY_COLS]
         rescue StandardError
           # unsupported on some platforms
         end
@@ -1054,8 +1092,15 @@ module Clacky
         # non-WSL hosts (and on WSL when not invoking Windows binaries)
         # keep their PTY stdin and continue to behave as before.
         stdin_redirect = exe_needs_stdin_isolation?(command) ? " </dev/null" : ""
+        # Inspect the original command before replacing multiline input with a script.
+        # Internal shell setup must execute inline to update the session itself.
+        command = prepare_execution_command(session, command) if with_hooks
         line   = %Q|#{hooks_line}{ #{command}\n}#{stdin_redirect}; __clacky_ec=$?; printf "\n__CLACKY_DONE_#{token}_%s__\n" "$__clacky_ec"\n|
+        session.echo_head = "{ #{command}".lines.last.chomp
         session.mutex.synchronize { session.writer.write(line) }
+      rescue StandardError
+        cleanup_session(session)
+        raise
       end
 
       # True when the command should run with stdin redirected from
@@ -1277,7 +1322,7 @@ module Clacky
           cleaned = OutputCleaner.clean(buffered)
           # Strip any wrapper echo that still slipped through (e.g. when a
           # session is reused and ZLE re-echoes our wrapper mid-stream).
-          cleaned = strip_command_echo(cleaned, marker_token: session.marker_token)
+          cleaned = strip_command_echo(cleaned, marker_token: session.marker_token, echo_head: session.echo_head)
           # Belt-and-braces: drop any line that still carries our internal
           # tokens.
           cleaned = cleaned.lines.reject do |ln|
@@ -1292,7 +1337,7 @@ module Clacky
           # doesn't produce a wall of whitespace in the streaming UI.
           cleaned = cleaned.gsub(/\n{3,}/, "\n\n")
           cleaned = cleaned.lstrip if cleaned.match?(/\A\n+\z/)
-          on_output.call(cleaned) unless cleaned.empty? || cleaned.match?(/\A\s*\z/)
+          on_output.call(hide_script_paths(session, cleaned)) unless cleaned.empty? || cleaned.match?(/\A\s*\z/)
         rescue StandardError
           # Streaming is best-effort — never let a UI bug abort the command.
         end
@@ -1394,10 +1439,7 @@ module Clacky
 
       # True when `command` spans multiple lines. Trailing newlines are
       # ignored — a single-line command terminated with "\n" is still
-      # single-line. Multi-line commands frequently hang the persistent
-      # PTY shell (incomplete heredoc, unclosed quote, multi-line block
-      # without closer) — the agent should write a script file and
-      # invoke it instead.
+      # single-line. Multi-line input is sourced in a subshell.
       private def multiline_command?(command)
         return false if command.nil?
         command.to_s.sub(/\n+\z/, "").include?("\n")

data/lib/clacky/tools/trash_manager.rb

@@ -490,9 +490,10 @@ module Clacky
         true
       end
 
-      # Permanently delete all sessions in the trash, or only those older than
-      # :days days. Returns the count of permanently deleted sessions.
-      def self.empty_trash_sessions(sessions_dir:, days: nil)
+      # Permanently delete all sessions in the trash, only those older than
+      # :days days, or only the sessions whose full id is in :ids.
+      # Returns the count of permanently deleted sessions.
+      def self.empty_trash_sessions(sessions_dir:, days: nil, ids: nil)
         trash_dir = Clacky::TrashDirectory.sessions_trash_dir
         return 0 unless Dir.exist?(trash_dir)
 
@@ -503,6 +504,7 @@ module Clacky
         Dir.glob(File.join(trash_dir, "*.json")).each do |filepath|
           session = sm.send(:load_session_file, filepath)
           next unless session
+          next if ids && !ids.include?(session[:session_id])
 
           if cutoff
             trash_time = session[:deleted_at] || session[:updated_at]

data/lib/clacky/tools/web_fetch.rb

@@ -5,6 +5,7 @@ require "uri"
 require "tmpdir"
 require "fileutils"
 require_relative "../utils/encoding"
+require_relative "../deepseek_web_tools"
 
 module Clacky
   module Tools
@@ -39,30 +40,88 @@ module Clacky
           return { error: "Invalid URL: #{e.message}" }
         end
 
-        begin
-          # Fetch the web page
-          response = fetch_url(uri)
-
-          # Extract content and force UTF-8 encoding at the source
-          content = Clacky::Utils::Encoding.to_utf8(response.body)
-          content_type = response["content-type"] || ""
-
-          # Parse HTML if it's an HTML page
-          if content_type.include?("text/html")
-            result = parse_html(content, max_length, url)
-            result[:url] = url
-            result[:content_type] = content_type
-            result[:status_code] = response.code.to_i
-            result[:error] = nil
-            result
-          else
-            # For non-HTML content, return raw text
-            result = handle_raw_content(content, max_length, url, content_type, response.code.to_i)
-            result
+        deepseek_error = nil
+        if deepseek_fetch_selected?
+          begin
+            return fetch_via_deepseek(url, max_length)
+          rescue StandardError => e
+            # A paid upstream failure must not cost the user the page, so keep
+            # going with the local scraper. The cooldown stops the next fetch
+            # from paying the same timeout.
+            deepseek_error = e
+            Clacky::DeepSeekWebTools.mark_unavailable!
           end
-        rescue StandardError => e
-          { error: "Failed to fetch URL: #{e.message}" }
         end
+
+        result = fetch_locally(uri, url, max_length)
+        if deepseek_error && result[:error]
+          result[:error] = "#{result[:error]} (DeepSeek: #{deepseek_error.message})"
+        end
+        result
+      end
+
+      private def fetch_locally(uri, url, max_length)
+        response = fetch_url(uri)
+
+        content = Clacky::Utils::Encoding.to_utf8(response.body)
+        content_type = response["content-type"] || ""
+
+        if content_type.include?("text/html")
+          result = parse_html(content, max_length, url)
+          result[:url] = url
+          result[:content_type] = content_type
+          result[:status_code] = response.code.to_i
+          result[:error] = nil
+          result
+        else
+          handle_raw_content(content, max_length, url, content_type, response.code.to_i)
+        end
+      rescue StandardError => e
+        { error: "Failed to fetch URL: #{e.message}" }
+      end
+
+      # DeepSeek renders pages to clean Markdown, which covers JS-heavy sites the
+      # local scraper cannot read. Runs only when the user picks it as the search
+      # provider; #execute falls back to the local scraper when it raises.
+      private def fetch_via_deepseek(url, max_length)
+        config = agent.config
+        key = config.deepseek_web_key
+        data = Clacky::DeepSeekWebTools.fetch(
+          url: url,
+          api_key: key,
+          base_url: config.deepseek_web_base_url(key)
+        )
+
+        text = data[:content].to_s
+        truncated = text.length > max_length
+        temp_file = nil
+        if truncated
+          temp_dir = Dir.mktmpdir
+          safe_name = extract_domain(url).gsub(/[^\w\-.]/, '_')[0...50]
+          timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+          temp_file = File.join(temp_dir, "#{safe_name}_#{timestamp}.md")
+          File.write(temp_file, text)
+        end
+
+        {
+          url: url,
+          title: data[:title].to_s.strip,
+          content_type: "text/markdown",
+          status_code: 200,
+          content: text[0, max_length],
+          truncated: truncated,
+          temp_file: temp_file,
+          error: nil
+        }
+      end
+
+      private def deepseek_fetch_selected?
+        return false unless agent
+        return false if Clacky::DeepSeekWebTools.cooling_down?
+
+        agent.config.deepseek_web_ready?
+      rescue StandardError
+        false
       end
 
       def handle_raw_content(content, max_length, url, content_type, status_code)

data/lib/clacky/tools/web_search.rb

@@ -6,6 +6,7 @@ require "uri"
 require "cgi"
 require "base64"
 require_relative "../utils/encoding"
+require_relative "../deepseek_web_tools"
 
 module Clacky
   module Tools
@@ -37,7 +38,9 @@ module Clacky
       SEARCHER_TIMEOUT = 30
       PARALLEL_ENDPOINT = "https://search.parallel.ai/mcp"
       PARALLEL_SNIPPET_MAX_CHARS = 400
-      PROVIDER_COOLDOWN_SECONDS = 600
+      # Shared by every provider, hosted or free: one failure keeps that
+      # provider out of the retry path for the whole window.
+      PROVIDER_COOLDOWN_SECONDS = 3600
 
       def execute(query:, max_results: 10, working_dir: nil)
         if query.nil? || query.strip.empty?
@@ -62,10 +65,13 @@ module Clacky
             }
           rescue StandardError => e
             # Avoid paying the same network/handshake failure on every search.
-            if provider == :parallel
+            case provider
+            when :deepseek
+              Clacky::DeepSeekWebTools.mark_unavailable!
+            when :parallel
               reset_parallel_client
               @parallel_unavailable_until = Time.now + PROVIDER_COOLDOWN_SECONDS
-            elsif provider == :duckduckgo
+            when :duckduckgo
               @ddg_unavailable_until = Time.now + PROVIDER_COOLDOWN_SECONDS
             end
             last_error = e
@@ -90,6 +96,10 @@ module Clacky
           "Configured search provider '#{name}' failed. #{reason} " \
             "Check the key and the script at #{Clacky::SearchConfig.script_path}, " \
             "or reconfigure it in Settings → Search."
+        elsif providers.include?(:deepseek)
+          "DeepSeek web search failed and no free engine returned results. #{reason} " \
+            "Check the API key and balance in Settings → Web Search; DeepSeek will be " \
+            "retried in #{PROVIDER_COOLDOWN_SECONDS / 60} minutes."
         else
           "All search providers failed. #{reason}"
         end
@@ -102,13 +112,23 @@ module Clacky
         # broken key or script look like a low-quality result set.
         return [:custom] if Clacky::SearchConfig.script_path
 
-        PROVIDERS.reject do |provider|
+        free_chain = PROVIDERS.reject do |provider|
           unavailable_until = case provider
                               when :parallel then @parallel_unavailable_until
                               when :duckduckgo then @ddg_unavailable_until
                               end
           unavailable_until && Time.now < unavailable_until
         end
+
+        return free_chain unless Clacky::SearchConfig.deepseek_web?
+
+        # DeepSeek leads the chain but does not replace the free engines: a
+        # missing key, an exhausted balance or an outage should degrade to a
+        # working search rather than return nothing.
+        return free_chain if Clacky::DeepSeekWebTools.cooling_down?
+        return free_chain unless deepseek_web_available?
+
+        [:deepseek] + free_chain
       end
 
       # ── Parallel Free MCP ──────────────────────────────────────────────────
@@ -171,6 +191,27 @@ module Clacky
         end.join("\n")
       end
 
+      # ── DeepSeek hosted search (paid, opt-in) ──────────────────────────────
+
+      private def deepseek_web_available?
+        return false unless agent
+
+        agent.config.deepseek_web_ready?
+      rescue StandardError
+        false
+      end
+
+      private def search_deepseek(query, max_results)
+        config = agent.config
+        key = config.deepseek_web_key
+        Clacky::DeepSeekWebTools.search(
+          query: query,
+          count: max_results,
+          api_key: key,
+          base_url: config.deepseek_web_base_url(key)
+        )
+      end
+
       # ── Configured searcher (~/.clacky/searchers/<provider>.rb) ────────────
 
       private def search_custom(query, max_results)

data/lib/clacky/ui2/ui_controller.rb

@@ -1396,7 +1396,7 @@ module Clacky
       #   * the countdown reaches zero with no interaction -> returns :timeout
       # @param seconds [Integer] Countdown duration
       # @return [String, Symbol] feedback text, or :timeout
-      def request_feedback_with_countdown(seconds: 10)
+      def request_feedback_with_countdown(seconds: 20)
         theme = ThemeManager.current_theme
 
         queue = Queue.new

data/lib/clacky/ui_interface.rb

@@ -145,9 +145,10 @@ module Clacky
     # Auto-approve countdown for ask_user. Shows a live countdown
     # and lets the user press a key to take over and answer. Returns :timeout
     # when no one intervenes (agent should auto-decide and continue), or a
-    # feedback string / "" when the user steps in. Non-interactive UIs (web,
-    # json, channel) have no human watching a TTY, so they default to :timeout.
-    def request_feedback_with_countdown(seconds: 10)
+    # feedback string / "" when the user steps in, or :answered when Web has
+    # queued a full answer for steering. Non-interactive UIs (json, channel)
+    # default to :timeout.
+    def request_feedback_with_countdown(seconds: 20)
       :timeout
     end
 

data/lib/clacky/utils/file_processor.rb

@@ -226,6 +226,57 @@ module Clacky
       MIME_TYPES[File.extname(path).downcase] || "application/octet-stream"
     end
 
+    # Quantize with a frequency-weighted median-cut palette using only chunky_png.
+    # Keep the input on failure so the caller retains its existing size handling.
+    def self.quantize_png_base64(b64)
+      require "base64"
+      require "chunky_png"
+
+      image = ChunkyPNG::Image.from_blob(Base64.strict_decode64(b64))
+      counts = Hash.new(0)
+      image.pixels.each { |color| counts[color] += 1 }
+      if counts.size > 256
+        # Cache each box's widest RGBA channel; split until at most 256 remain.
+        make_box = lambda do |colors|
+          ranges = [24, 16, 8, 0].map do |shift|
+            values = colors.map { |color| (color >> shift) & 255 }
+            values.max - values.min
+          end
+          channel = ranges.each_index.max_by { |i| ranges[i] }
+          [colors, [24, 16, 8, 0][channel], ranges[channel]]
+        end
+        boxes = [make_box.call(counts.keys)]
+        while boxes.size < 256
+          index = boxes.each_index.max_by { |i| boxes[i][2] }
+          colors, shift, range = boxes.delete_at(index)
+          break if range.zero?
+
+          colors.sort_by! { |color| (color >> shift) & 255 }
+          halfway = colors.sum { |color| counts[color] } / 2.0
+          total = 0
+          split = colors.index { |color| (total += counts[color]) >= halfway } + 1
+          split = [split, colors.size - 1].min
+          boxes << make_box.call(colors.take(split))
+          boxes << make_box.call(colors.drop(split))
+        end
+
+        mapping = {}
+        boxes.each do |colors, _shift, _range|
+          weight = colors.sum { |color| counts[color] }
+          channels = [24, 16, 8, 0].map do |shift|
+            (colors.sum { |color| ((color >> shift) & 255) * counts[color] }.to_f / weight).round
+          end
+          representative = ChunkyPNG::Color.rgba(*channels)
+          colors.each { |color| mapping[color] = representative }
+        end
+        image.pixels.map! { |color| mapping.fetch(color) }
+      end
+      Base64.strict_encode64(image.to_blob(color_mode: ChunkyPNG::COLOR_INDEXED))
+    rescue StandardError => e
+      Clacky::Logger.debug("image_quantization_skipped", format: "png", reason: e.message)
+      b64
+    end
+
     # Downscale a base64-encoded image so its width is at most max_width pixels.
     #
     # Strategy: