openclacky 1.3.3 → 1.3.5

data/lib/clacky/server/session_registry.rb

@@ -44,6 +44,7 @@ module Clacky
           error:                nil,
           error_code:           nil,
           top_up_url:           nil,
+          raw_message:          nil,
           updated_at:           nil,
           agent:                nil,
           ui:                   nil,
@@ -169,7 +170,7 @@ module Clacky
             live_name  = s[:agent]&.name
             live_name  = nil if live_name&.empty?
           live_cost_source = s[:agent]&.cost_source
-          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url], raw_message: s[:raw_message],
             updated_at: s[:updated_at]&.iso8601,
             model: model_info&.dig(:model), model_id: model_info&.dig(:id), name: live_name,
             total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
@@ -269,7 +270,7 @@ module Clacky
           model_info = s[:agent]&.current_model_info
           live_name  = s[:agent]&.name
           live_name  = nil if live_name&.empty?
-          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url], raw_message: s[:raw_message],
             updated_at: s[:updated_at]&.iso8601,
             model: model_info&.dig(:model), model_id: model_info&.dig(:id),
             name: live_name, total_tasks: s[:agent]&.total_tasks,
@@ -296,6 +297,7 @@ module Clacky
           error:         ls ? ls[:error] : nil,
           error_code:    ls&.dig(:error_code),
           top_up_url:    ls&.dig(:top_up_url),
+          raw_message:   ls&.dig(:raw_message),
           model:         ls&.dig(:model),
           model_id:      ls&.dig(:model_id),
           card_model:    ls&.dig(:card_model),
@@ -440,7 +442,7 @@ module Clacky
 
       private def persist_and_release(id, session)
         agent = session[:agent]
-        @session_manager&.save(agent.to_session_data(status: :success)) if agent
+        @session_manager&.save(agent.to_session_data(status: :success, preserve_updated_at: true)) if agent
 
         @mutex.synchronize do
           s = @sessions[id]

data/lib/clacky/server/web_ui_controller.rb

@@ -230,12 +230,13 @@ module Clacky
         @broadcaster.call(@session_id, event)
       end
 
-      def show_error(message, code: nil, top_up_url: nil)
+      def show_error(message, code: nil, top_up_url: nil, raw_message: nil)
         payload = { message: message }
         payload[:code] = code if code
         payload[:top_up_url] = top_up_url if top_up_url
+        payload[:raw_message] = raw_message if raw_message
         emit("error", **payload)
-        forward_to_subscribers { |sub| sub.show_error(message, code: code, top_up_url: top_up_url) }
+        forward_to_subscribers { |sub| sub.show_error(message, code: code, top_up_url: top_up_url, raw_message: raw_message) }
       end
 
       def show_success(message)

data/lib/clacky/shell_hook_loader.rb

@@ -178,4 +178,4 @@ module Clacky
       base
     end
   end
-end
+end

data/lib/clacky/skill_loader.rb

@@ -441,13 +441,11 @@ module Clacky
 
     # Load default skills from gem's default_skills directory
     private def load_default_skills
-      # Get the gem's lib directory
       gem_lib_dir = File.expand_path("../", __dir__)
       default_skills_dir = File.join(gem_lib_dir, "clacky", "default_skills")
 
       return unless Dir.exist?(default_skills_dir)
 
-      # Load each skill directory
       Dir.glob(File.join(default_skills_dir, "*/SKILL.md")).each do |skill_file|
         skill_dir = File.dirname(skill_file)
         skill_name = File.basename(skill_dir)
@@ -459,6 +457,20 @@ module Clacky
           @errors << "Failed to load default skill #{skill_name}: #{e.message}"
         end
       end
+
+      # Also load skills bundled inside default_extensions/*/skills/
+      ext_skills_dir = File.join(gem_lib_dir, "clacky", "default_extensions")
+      Dir.glob(File.join(ext_skills_dir, "*/skills/*/SKILL.md")).each do |skill_file|
+        skill_dir = File.dirname(skill_file)
+        skill_name = File.basename(skill_dir)
+
+        begin
+          skill = Skill.new(Pathname.new(skill_dir))
+          register_skill(skill, source: :default)
+        rescue StandardError => e
+          @errors << "Failed to load default skill #{skill_name}: #{e.message}"
+        end
+      end
     end
   end
 end

data/lib/clacky/tools/edit.rb

@@ -67,8 +67,20 @@ module Clacky
             }
           end
 
-          # Perform replacement
-          content = replace_all ? content.gsub(actual_old_string, new_string) : content.sub(actual_old_string, new_string)
+          # Perform literal replacement.
+          #
+          # NOTE: Use the block form (`sub(old) { new }`) instead of the
+          # two-arg form (`sub(old, new)`). The two-arg form interprets
+          # backslash escapes (\&, \1, \`, \', \\) in the replacement
+          # as sed-style backreferences, silently mangling literal
+          # backslashes and these escape sequences. The block form
+          # performs no such interpretation, matching the edit tool's
+          # literal-replacement contract.
+          content = if replace_all
+                      content.gsub(actual_old_string) { new_string }
+                    else
+                      content.sub(actual_old_string) { new_string }
+                    end
 
           File.write(path, content)
 

data/lib/clacky/tools/terminal/output_cleaner.rb

@@ -35,9 +35,7 @@ module Clacky
         def clean(raw)
           return "" if raw.nil? || raw.empty?
 
-          s = raw.dup
-          s.force_encoding(Encoding::UTF_8)
-          s = s.scrub("?") unless s.valid_encoding?
+          s = Clacky::Utils::Encoding.pty_to_utf8(raw)
 
           s = s.gsub(CSI_REGEX, "")
           s = s.gsub(OSC_REGEX, "")

data/lib/clacky/tools/terminal.rb

@@ -340,10 +340,6 @@ module Clacky
           project_root: cwd || Dir.pwd
         )
 
-        # PowerShell 5 on Chinese Windows emits CP936/GBK by default; force
-        # UTF-8 so our PTY (which decodes as UTF-8) doesn't see ??? bytes.
-        safe_command = force_powershell_utf8(safe_command)
-
         # Background / dedicated path — never reuse the persistent shell,
         # because these commands stay running and would occupy the slot.
         if background
@@ -1522,45 +1518,6 @@ module Clacky
         return "" if lines.empty?
         lines.last(DISPLAY_TAIL_LINES).join("\n")
       end
-
-      # PowerShell 5 on Chinese Windows defaults [Console]::OutputEncoding
-      # to CP936/GBK; our PTY decodes as UTF-8 so non-ASCII output becomes
-      # `???`. Inject UTF-8 setup into the user's PowerShell command so the
-      # shell emits UTF-8 bytes regardless of host locale.
-      POWERSHELL_PREAMBLE =
-        "[Console]::OutputEncoding=[Text.Encoding]::UTF8;"
-
-      # Only rewrites simple `powershell[.exe]` / `pwsh[.exe]` invocations.
-      # Skips -File / -EncodedCommand / commands already handling encoding /
-      # pipelines (anything risky to splice).
-      private def force_powershell_utf8(command)
-        cmd = command.to_s
-        return command unless cmd =~ /\A\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\b/i
-        return command if cmd =~ /OutputEncoding/i
-        return command if cmd =~ /\s-(?:File|EncodedCommand|enc|f)\b/i
-
-        # `-Command "..."` form: pipeline / chain characters inside the
-        # quoted body are PowerShell-internal, not shell-level, so we splice
-        # safely into the quoted string.
-        if (m = cmd.match(/\A(\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\s+(?:[^"'\s]+\s+)*?-(?:Command|c)\s+)(["'])(.*)\2(\s*(?:<\s*\S+\s*)?)\z/i))
-          head, quote, body, tail = m[1], m[2], m[3], m[4].to_s
-          return "#{head}#{quote}#{POWERSHELL_PREAMBLE}#{body}#{quote}#{tail}"
-        end
-
-        # Outside the quoted-Command form, refuse to splice if there's any
-        # shell-level pipe / chain — too risky to get the boundaries right.
-        return command if cmd =~ /[|&;]/
-
-        if (m = cmd.match(/\A(\s*(?:powershell(?:\.exe)?|pwsh(?:\.exe)?))(.*)\z/i))
-          exe, rest = m[1], m[2].to_s.strip
-          return command if rest.start_with?("-") && rest !~ /\A-(?:Command|c)\b/i
-          rest = rest.sub(/\A-(?:Command|c)\b\s*/i, "")
-          inner = rest.empty? ? POWERSHELL_PREAMBLE.chomp(";") : "#{POWERSHELL_PREAMBLE}#{rest}"
-          return %Q{#{exe} -Command "#{inner}"}
-        end
-
-        command
-      end
     end
   end
 end

data/lib/clacky/ui2/components/modal_component.rb

@@ -326,7 +326,7 @@ module Clacky
               print "\e[?25l"
               return :cancelled
             when "\u0015"  # Ctrl+U - clear line
-              buffer = ''
+              buffer = String.new
               cursor_pos = 0
             else
               # Regular character input

data/lib/clacky/ui2/ui_controller.rb

@@ -17,7 +17,7 @@ module Clacky
       include Clacky::UIInterface
 
       attr_reader :layout, :renderer, :running, :inline_input, :input_area
-      attr_accessor :config
+      attr_accessor :config, :available_models
 
       def initialize(config = {})
         @renderer = ViewRenderer.new
@@ -38,6 +38,7 @@ module Clacky
         @todo_area = Components::TodoArea.new
         @welcome_banner = Components::WelcomeBanner.new
         @inline_input = nil  # Created when needed
+        @feedback_countdown = nil  # Active auto-approve feedback countdown session
         @layout = LayoutManager.new(
           input_area: @input_area,
           todo_area: @todo_area
@@ -47,6 +48,7 @@ module Clacky
         @input_callback = nil
         @interrupt_callback = nil
         @time_machine_callback = nil
+        @model_switch_callback = nil
         @tasks_count = 0
         @total_cost = 0.0
         @session_id = nil
@@ -192,6 +194,12 @@ module Clacky
         @time_machine_callback = block
       end
 
+      # Set callback for model switch (from /model slash command)
+      # @param block [Proc] Callback to execute on model switch
+      def on_model_switch(&block)
+        @model_switch_callback = block
+      end
+
       # Set agent for command suggestions
       # @param agent [Clacky::Agent] The agent instance with skill management
       # @param agent_profile [Clacky::AgentProfile, nil] Current agent profile for skill filtering
@@ -867,7 +875,7 @@ module Clacky
 
       # Show error message
       # @param message [String] Error message
-      def show_error(message, code: nil, top_up_url: nil)
+      def show_error(message, code: nil, top_up_url: nil, raw_message: nil)
         output = @renderer.render_error(message)
         append_output(output)
       end
@@ -1047,6 +1055,99 @@ module Clacky
         end
       end
 
+      # Auto-approve countdown for request_user_feedback: show a single live
+      # countdown line. If the user presses any key before timeout, collect
+      # their answer and return it (intervention). Otherwise return :timeout so
+      # the agent auto-decides and continues.
+      # @param seconds [Integer] Countdown duration
+      # @return [String, Symbol] feedback string, "" (bare Enter), or :timeout
+      # Show a live single-line countdown in the output area while keeping the
+      # normal input box usable. The agent thread blocks here until either:
+      #   * the user submits a message in the regular input box -> returns the text
+      #   * the user starts typing (cancels the auto-timeout but keeps waiting)
+      #   * 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)
+        theme = ThemeManager.current_theme
+
+        queue = Queue.new
+        entry_id = @layout.append_output(countdown_prompt(seconds, theme))
+
+        session = {
+          queue: queue,
+          entry_id: entry_id,
+          intervened: false,
+          watchdog: nil
+        }
+        @feedback_countdown = session
+
+        session[:watchdog] = Thread.new do
+          remaining = seconds.to_i
+          while remaining.positive?
+            break if session[:intervened]
+
+            @layout.replace_entry(entry_id, countdown_prompt(remaining, theme))
+            sleep 1
+            remaining -= 1
+          end
+          queue.push(:timeout) unless session[:intervened]
+        end
+
+        result = queue.pop
+        session[:watchdog].kill if session[:watchdog]&.alive?
+        @feedback_countdown = nil
+        @layout.remove_entry(entry_id) if entry_id
+        @layout.recalculate_layout
+        @layout.render_all
+
+        if result == :timeout
+          append_output(theme.format_text("  No response — continuing automatically.", :thinking))
+        elsif result.to_s.strip.empty?
+          append_output(theme.format_text("  → (continue)", :success))
+          result = ""
+        end
+
+        result
+      end
+
+      # Cancel the countdown's auto-timeout when the user starts interacting,
+      # but keep waiting for their submitted answer. Returns true if a
+      # countdown was active.
+      private def intervene_feedback_countdown
+        session = @feedback_countdown
+        return false unless session && !session[:intervened]
+
+        session[:intervened] = true
+        session[:watchdog].kill if session[:watchdog]&.alive?
+        if session[:entry_id]
+          @layout.remove_entry(session[:entry_id])
+          session[:entry_id] = nil
+          @layout.recalculate_layout
+          @layout.render_all
+        end
+        true
+      end
+
+      private def countdown_prompt(remaining, theme)
+        theme.format_text("  Auto-continuing in #{remaining}s — type your answer to step in…", :info)
+      end
+
+      # Whether a keystroke should count as the user stepping into a countdown.
+      # Plain typing and pastes do; pure scroll/navigation keys do not.
+      private def countdown_intervening_key?(key)
+        case key
+        when Hash
+          key[:type] == :rapid_input
+        when String
+          key.length >= 1 && key.ord >= 32
+        when :backspace, :enter
+          true
+        else
+          false
+        end
+      end
+
       # Show diff between old and new content
       # @param old_content [String] Old content
       # @param new_content [String] New content
@@ -1199,7 +1300,7 @@ module Clacky
       # Check if API key is configured and show warning if missing
       private def check_api_key_configuration
         config = Clacky::AgentConfig.load
-        
+
         if !config.models_configured?
           show_warning("No models configured! Please run /config to set up your models and API keys.")
         elsif config.api_key.nil? || config.api_key.empty?
@@ -1243,7 +1344,7 @@ module Clacky
         while @running
           # Process any pending resize events
           @layout.process_pending_resize
-          
+
           key = @layout.screen.read_key(timeout: 0.1)
           next unless key
 
@@ -1284,6 +1385,13 @@ module Clacky
           return
         end
 
+        # During an auto-approve feedback countdown the normal input box stays
+        # live; the first meaningful keystroke cancels the auto-timeout so the
+        # user can finish typing their answer without being rushed.
+        if @feedback_countdown && !@feedback_countdown[:intervened] && countdown_intervening_key?(key)
+          intervene_feedback_countdown
+        end
+
         result = @input_area.handle_key(key)
 
         # Handle height change first
@@ -1409,6 +1517,14 @@ module Clacky
           append_output(output)
         end
 
+        # If an auto-approve feedback countdown is waiting for an answer, this
+        # submission IS that answer — deliver it to the waiting agent thread
+        # instead of starting a brand-new turn.
+        if (session = @feedback_countdown)
+          session[:queue].push(data[:text].to_s)
+          return
+        end
+
         # Then call callback (allows interrupting previous agent before processing new input)
         @input_callback&.call(data[:text], data[:files])
       end
@@ -1418,31 +1534,31 @@ module Clacky
       # @return [Hash, nil] Hash with updated config values, or nil if cancelled
       public def show_config_modal(current_config, test_callback: nil)
         modal = Components::ModalComponent.new
-        
+
         loop do
           # Build menu choices
           choices = []
-          
+
           # Add model list
           current_config.models.each_with_index do |model, idx|
             is_current = (idx == current_config.current_model_index)
             model_name = model["model"] || "unnamed"
             masked_key = mask_api_key(model["api_key"])
-            
+
             # Add type badge if present
             type_badge = case model["type"]
                         when "default" then "[default] "
                         when "lite" then "[lite] "
                         else ""
                         end
-            
+
             display_name = "#{type_badge}#{model_name} (#{masked_key})"
             choices << {
               name: display_name,
               value: { action: :switch, model_id: model["id"] }
             }
           end
-          
+
           # Add action buttons
           choices << { name: "─" * 50, disabled: true }
           choices << { name: "[+] Add New Model", value: { action: :add } }
@@ -1451,16 +1567,16 @@ module Clacky
             choices << { name: "[-] Delete Model", value: { action: :delete } } if current_config.models.length > 1
           end
           choices << { name: "[X] Close", value: { action: :close } }
-          
+
           # Show menu
           result = modal.show(
-            title: "Model Configuration", 
+            title: "Model Configuration",
             choices: choices,
             on_close: -> { @layout.rerender_all }
           )
-          
+
           return nil if result.nil?
-          
+
           case result[:action]
           when :switch
             # Just signal the caller which model to switch to.
@@ -1692,16 +1808,16 @@ module Clacky
 
         result # Return selected task_id or nil
       end
-      
+
       # Show form for editing a model
       # @param model [Hash, nil] Existing model hash or nil for new model
       # @return [Hash, nil] Updated model hash or nil if cancelled
       private def show_model_edit_form(model, test_callback: nil)
         modal = Components::ModalComponent.new
-        
+
         is_new = model.nil?
         model ||= {}
-        
+
         # For new models, show provider selection first
         selected_provider = nil
         if is_new
@@ -1711,32 +1827,32 @@ module Clacky
           end
           provider_choices << { name: "─" * 40, disabled: true }
           provider_choices << { name: "Custom (manual configuration)", value: "custom" }
-          
+
           # Show provider selection
           selected_provider = modal.show(
             title: "Select Provider",
             choices: provider_choices,
             on_close: -> { @layout.rerender_all }
           )
-          
+
           # User cancelled
           return nil if selected_provider.nil?
         end
-        
+
         # Prepare masked API key for display
         masked_key = mask_api_key(model["api_key"])
-        
+
         # Pre-fill values from provider preset if selected
         provider_preset = nil
         if selected_provider && selected_provider != "custom"
           provider_preset = Clacky::Providers.get(selected_provider)
         end
-        
+
         # Get default values from provider or existing model
         default_model = provider_preset ? provider_preset["default_model"] : model["model"]
         default_base_url = provider_preset ? provider_preset["base_url"] : model["base_url"]
         default_api_key = model["api_key"] || ""
-        
+
         # Define fields
         fields = [
           {
@@ -1756,7 +1872,7 @@ module Clacky
             default: default_base_url || ""
           }
         ]
-        
+
         # Create validator if test_callback provided
         validator = if test_callback
           lambda do |values|
@@ -1765,14 +1881,14 @@ module Clacky
             model_name = values[:model].to_s.empty? ? model["model"] : values[:model]
             base_url = values[:base_url].to_s.empty? ? model["base_url"] : values[:base_url]
             anthropic_format = model["anthropic_format"] # Not editable in form, use model's value
-            
+
             test_config_values = {
               "api_key" => api_key,
               "model" => model_name,
               "base_url" => base_url,
               "anthropic_format" => anthropic_format
             }
-            
+
             # For new models, require all fields
             if is_new
               if test_config_values["api_key"].to_s.empty?
@@ -1785,7 +1901,7 @@ module Clacky
                 return { success: false, error: "Base URL is required" }
               end
             end
-            
+
             # Create a temporary config for testing
             temp_config = Clacky::AgentConfig.new(models: [test_config_values], current_model_index: 0)
             test_callback.call(temp_config)
@@ -1793,7 +1909,7 @@ module Clacky
         else
           nil
         end
-        
+
         # Determine modal title based on provider
         modal_title = if is_new && selected_provider && selected_provider != "custom"
           provider_name = Clacky::Providers.get(selected_provider)&.dig("name") || selected_provider
@@ -1803,7 +1919,7 @@ module Clacky
         else
           "Edit Model"
         end
-        
+
         # Show modal and collect values
         result = modal.show(
           title: modal_title,
@@ -1811,9 +1927,9 @@ module Clacky
           validator: validator,
           on_close: -> { @layout.rerender_all }
         )
-        
+
         return nil if result.nil?
-        
+
         # Merge with existing model values or provider defaults
         {
           api_key: result[:api_key].to_s.empty? ? model["api_key"] : result[:api_key],
@@ -1822,7 +1938,7 @@ module Clacky
           provider: selected_provider
         }
       end
-      
+
       # Mask API key for display
       private def mask_api_key(api_key)
         if api_key && !api_key.empty?

data/lib/clacky/ui_interface.rb

@@ -28,7 +28,7 @@ module Clacky
     # === Status messages ===
     def show_info(message, prefix_newline: true); end
     def show_warning(message); end
-    def show_error(message, code: nil, top_up_url: nil); end
+    def show_error(message, code: nil, top_up_url: nil, raw_message: nil); end
     def show_success(message); end
     def log(message, level: :info); end
 
@@ -131,6 +131,15 @@ module Clacky
     # === Blocking interaction ===
     def request_confirmation(message, default: true); end
 
+    # Auto-approve countdown for request_user_feedback. 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)
+      :timeout
+    end
+
     # === Input control (CLI layer) ===
     def clear_input; end
     def set_input_tips(message, type: :info); end

data/lib/clacky/utils/encoding.rb

@@ -75,6 +75,31 @@ module Clacky
         to_utf8(data)
       end
 
+      # Decode a raw PTY byte stream to valid UTF-8, auto-detecting the source
+      # encoding. UTF-8 is tried first (Linux/macOS and modern programs); when
+      # the bytes are not valid UTF-8 they are decoded as GBK/CP936 (Simplified
+      # Chinese Windows powershell.exe / cmd.exe default output); anything that
+      # still fails is scrubbed.
+      #
+      # MUST be called on complete byte runs — callers slice on "\n" (0x0A),
+      # which is never a trailing byte of a GBK or UTF-8 multibyte sequence, so
+      # a character is never split across the boundary.
+      #
+      # @param data [String, nil] raw PTY bytes (binary/ASCII-8BIT)
+      # @return [String] valid UTF-8 string
+      def self.pty_to_utf8(data)
+        return "" if data.nil? || data.empty?
+
+        s = data.dup.force_encoding("UTF-8")
+        return s if s.valid_encoding?
+
+        data.dup
+            .force_encoding("GBK")
+            .encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+      rescue Encoding::InvalidByteSequenceError, Encoding::UndefinedConversionError
+        to_utf8(data)
+      end
+
       # Return an ASCII-safe UTF-8 copy of *str* suitable for security regex
       # pattern matching.  Any byte that is not valid in the source encoding, or
       # that cannot be represented in UTF-8, is replaced with '?'.  The

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.3.3"
+  VERSION = "1.3.5"
 end