openclacky 1.5.13 → 1.5.15

data/lib/clacky/agent_config.rb

@@ -158,7 +158,7 @@ module Clacky
     DEFAULT_COMPRESSION_THRESHOLD = 150_000
     DEFAULT_MESSAGE_COUNT_THRESHOLD = 200
 
-    attr_accessor :permission_mode, :max_tokens, :verbose,
+    attr_accessor :input_behavior, :permission_mode, :max_tokens, :verbose,
                   :enable_compression, :enable_idle_compression, :enable_prompt_caching,
                   :compression_threshold, :message_count_threshold,
                   :models, :current_model_index, :current_model_id,
@@ -170,6 +170,7 @@ module Clacky
 
     def initialize(options = {})
       @permission_mode = validate_permission_mode(options[:permission_mode])
+      @input_behavior = %w[queue steer interrupt].include?(options[:input_behavior].to_s) ? options[:input_behavior].to_s : "queue"
       @max_tokens = options[:max_tokens] || 16384
       @verbose = options[:verbose] || false
       @enable_compression = options[:enable_compression].nil? ? true : options[:enable_compression]
@@ -454,7 +455,7 @@ module Clacky
     CONFIG_SETTINGS_KEYS = %w[
       enable_compression enable_idle_compression enable_prompt_caching
       compression_threshold message_count_threshold
-      memory_update_enabled
+      memory_update_enabled input_behavior
       skill_evolution max_running_agents max_idle_agents
       default_working_dir
       proxy_url clacky_license_server
@@ -468,6 +469,7 @@ module Clacky
         m.reject { |k, _| RUNTIME_ONLY_FIELDS.include?(k) }
       end
       settings = {
+        "input_behavior" => @input_behavior,
         "enable_compression" => @enable_compression,
         "enable_idle_compression" => @enable_idle_compression,
         "enable_prompt_caching" => @enable_prompt_caching,
@@ -1161,7 +1163,7 @@ module Clacky
       # find_by_base_url only matches registered preset URLs, so localhost
       # and other non-openclacky endpoints correctly return nil.
       provider_id = Clacky::Providers.find_by_base_url(m["base_url"])
-      return nil unless provider_id == "openclacky"
+      return nil unless provider_id == Clacky::Providers::OPENCLACKY_ID
 
       fallback_url = Clacky::Providers.fallback_base_url(provider_id)
       return nil unless fallback_url

data/lib/clacky/billing/billing_store.rb

@@ -20,7 +20,7 @@ module Clacky
       # list never drifts from providers.rb as models are added or removed.
       def openclacky_models
         @openclacky_models ||= begin
-          preset = Clacky::Providers.get("openclacky")
+          preset = Clacky::Providers.get(Clacky::Providers::OPENCLACKY_ID)
           return [] unless preset
           OPENCLACKY_MODEL_KINDS.flat_map { |kind| preset[kind] || [] }.uniq
         end
@@ -30,7 +30,7 @@ module Clacky
       # carry an explicit provider id; legacy records (written before the
       # field existed) are detected by matching the full openclacky model list.
       def openclacky_record?(record)
-        return true if record.provider == "openclacky"
+        return true if record.provider == Clacky::Providers::OPENCLACKY_ID
         openclacky_models.include?(record.model.to_s)
       end
 

data/lib/clacky/billing/platform_billing.rb

@@ -15,11 +15,18 @@ module Clacky
       # alias → real upstream model id, used to translate the model filter
       # before querying the platform API. Vertex ids are preferred as the
       # "primary" id where the gateway can dispatch an alias two ways.
+      # Retired aliases stay here so usage recorded under them still resolves.
       ALIAS_TO_REAL = {
         # deepseek (dsk-)
+        "dsk-deepseek-flash"               => "deepseek-flash",
         "dsk-deepseek-v4-pro"              => "deepseek-v4-pro",
         "dsk-deepseek-v4-flash"            => "deepseek-v4-flash",
         "dsk-deepseek-v4-flash-vision-exp" => "deepseek-v4-flash-vision-exp",
+        # gpt via bedrock (abs-, OpenAI-compatible endpoint)
+        "abs-gpt-6-astra"  => "global.openai.gpt-6-astra",
+        "abs-gpt-5.6-sol"   => "global.openai.gpt-5.6-sol",
+        "abs-gpt-5.6-terra" => "global.openai.gpt-5.6-terra",
+        "abs-gpt-5.6-luna"  => "global.openai.gpt-5.6-luna",
         # claude via bedrock (abs-)
         "abs-claude-fable-5-1"  => "global.anthropic.claude-fable-5-1",
         "abs-claude-fable-5"    => "global.anthropic.claude-fable-5",

data/lib/clacky/brand_config.rb

@@ -53,7 +53,7 @@ module Clacky
     attr_reader :product_name, :package_name, :license_key, :license_activated_at,
                 :license_expires_at, :license_last_heartbeat, :device_id,
                 :logo_url, :support_contact, :license_user_id,
-                :support_qr_url, :theme_color, :homepage_url,
+                :support_qr_url, :theme_color,
                 :distribution_last_refreshed_at, :license_last_heartbeat_failure
 
     def initialize(attrs = {})
@@ -856,7 +856,7 @@ module Clacky
     # Requires an activated license. Returns { success:, extensions: [], error: }.
     # Each extension carries name + latest_version.download_url so
     # install_brand_extension! can consume it directly.
-    def fetch_brand_extensions!
+    def fetch_brand_extensions!(sort: nil)
       return { success: false, error: "License not activated", extensions: [] } unless activated?
 
       user_id   = parse_user_id_from_key(@license_key)
@@ -872,6 +872,7 @@ module Clacky
         nonce:     nonce,
         signature: OpenSSL::HMAC.hexdigest("SHA256", @license_key, message)
       }
+      payload[:sort] = sort if sort
 
       response = api_post("/api/v1/licenses/extensions", payload)
 
@@ -1289,9 +1290,11 @@ module Clacky
 
     # Synchronise brand skills in the background.
     #
-    # Fetches the remote skills list and installs any skill whose remote version
-    # differs from the locally installed version.  The work runs in a daemon
-    # Thread so it never blocks the caller (typically Agent startup).
+    # Fetches the remote skills list and installs every skill that is missing
+    # locally or has a newer remote version — skills the brand publishes after
+    # this install was activated therefore arrive without user action.  The work
+    # runs in a daemon Thread so it never blocks the caller (typically Agent
+    # startup).
     #
     # If the license is not activated the method returns immediately without
     # spawning a thread.
@@ -1299,10 +1302,7 @@ module Clacky
     # @param on_complete [Proc, nil] Optional callback called with the sync
     #   results array once all downloads finish (useful for tests / UI feedback).
     # @return [Thread, nil] The background thread, or nil if skipped.
-    # install_new: when true, install ALL remote skills regardless of whether they
-    # were previously installed. Used on first activation so every brand skill is
-    # available immediately without the user clicking Install one-by-one.
-    def sync_brand_skills_async!(on_complete: nil, install_new: false)
+    def sync_brand_skills_async!(on_complete: nil)
       return nil unless activated?
       return nil if ENV["CLACKY_TEST"] == "1"
 
@@ -1321,16 +1321,13 @@ module Clacky
             delete_brand_skill!(local_name) unless remote_skill_names.include?(local_name)
           end
 
-          # When install_new is true (e.g. on first activation) install every
-          # remote skill. Otherwise limit auto-sync to skills already installed
-          # locally that have a newer version available — new skills must be
-          # installed explicitly by the user from the Brand Skills panel.
+          # Install every remote skill that is missing locally or has a newer
+          # version available, so the local catalogue converges on the brand's
+          # without the user clicking Install in the Brand Skills panel.
           installed = installed_brand_skills
-          skills_to_install = if install_new
-                                result[:skills].select { |s| s["needs_update"] || !installed.key?(s["name"]) }
-                              else
-                                result[:skills].select { |s| s["needs_update"] }
-                              end
+          skills_to_install = result[:skills].select do |s|
+            s["needs_update"] || !installed.key?(s["name"])
+          end
           results = skills_to_install.map do |skill_info|
             install_brand_skill!(skill_info)
           end
@@ -1649,6 +1646,17 @@ module Clacky
       # Non-fatal — metadata write failure should not break the upload flow
     end
 
+    # Vendors may configure a bare domain ("example.com"). Without a scheme the
+    # browser treats it as a relative path and resolves it against the local
+    # server, so normalize on read to cover every consumer at once.
+    def homepage_url
+      raw = @homepage_url.to_s.strip
+      return nil if raw.empty?
+      return raw if raw.match?(%r{\A[a-z][a-z0-9+.\-]*:}i)
+
+      "https://#{raw}"
+    end
+
     # Returns a hash representation for JSON serialization (e.g. /api/brand).
     def to_h
       {
@@ -1658,7 +1666,7 @@ module Clacky
         support_contact:    @support_contact,
         support_qr_url:     @support_qr_url,
         theme_color:        @theme_color,
-        homepage_url:       @homepage_url,
+        homepage_url:       homepage_url,
         branded:            branded?,
         activated:          activated?,
         expired:            expired?,

data/lib/clacky/cli.rb

@@ -345,6 +345,29 @@ module Clacky
         ui_controller.show_success("Switched to model: #{config.model_name}")
       end
 
+      # Handle the `/think` slash command — pick the reasoning effort level
+      # for the current session. "off" normalizes to nil (provider default),
+      # matching the Web UI's reasoning_effort switcher semantics.
+      private def handle_think_command(ui_controller, agent, session_manager = nil)
+        choice = ui_controller.show_reasoning_effort_menu(agent.reasoning_effort)
+        return if choice.nil?
+
+        agent.reasoning_effort = choice
+
+        # The override lives in the session file (not config.yml), so persist
+        # it now — otherwise it would be lost if the user quits before the
+        # next task.
+        session_manager&.save(agent.to_session_data(updated_at: Time.now))
+
+        # Reflect the change in the session bar (appended after the model name)
+        ui_controller.config[:reasoning_effort] = agent.reasoning_effort
+        ui_controller.update_sessionbar
+
+        current = agent.reasoning_effort
+        message = current ? "Thinking level set to #{current}" : "Thinking level: off (provider default)"
+        ui_controller.show_success(message)
+      end
+
       private def handle_time_machine_command(ui_controller, agent, session_manager)
         # Get task history from agent
         history = agent.get_task_history(limit: 10)
@@ -874,6 +897,7 @@ module Clacky
             working_dir: working_dir,
             mode: agent_config.permission_mode.to_s,
             model: agent_config.model_name,
+            reasoning_effort: agent.reasoning_effort,
             theme: theme_name
           )
         end
@@ -889,6 +913,7 @@ module Clacky
 
         # Track current working thread (agent or idle compression that can be interrupted)
         current_task_thread = nil
+        input_submission_mutex = Mutex.new
         shutting_down = false
 
         # Idle compression timer - triggers compression after 180s of inactivity
@@ -988,7 +1013,26 @@ module Clacky
         end
 
         # Set up input handler
-        ui_controller.on_input do |input, files, display: nil|
+        if ui_controller.respond_to?(:queue_input_while_running=)
+          ui_controller.queue_input_while_running = -> { current_task_thread&.alive? && %w[queue steer].include?(agent_config.input_behavior) }
+        end
+        if ui_controller.respond_to?(:input_area)
+          ui_controller.input_area.guidance_lines_provider = -> { ui_controller.guidance_lines }
+        end
+        ui_controller.show_input_queue(agent.pending_inputs) if ui_controller.respond_to?(:show_input_queue)
+        handle_input = lambda do |input, files, display: nil, force_interrupt: false|
+          if input.to_s.match?(%r{\A/input-mode(?:\s|\z)})
+            mode = input.split[1]
+            if %w[queue interrupt steer].include?(mode)
+              agent_config.input_behavior = mode
+              agent_config.save
+              ui_controller.show_info("Input mode: #{mode}")
+            else
+              ui_controller.show_info("Current input mode: #{agent_config.input_behavior}\n/input-mode queue · /input-mode steer · /input-mode interrupt")
+            end
+            next
+          end
+
           # Handle commands
           case input.downcase.strip
           when "/config"
@@ -997,6 +1041,9 @@ module Clacky
           when "/model"
             handle_model_command(ui_controller, agent_config, agent, session_manager)
             next
+          when "/think"
+            handle_think_command(ui_controller, agent, session_manager)
+            next
           when "/undo"
             handle_time_machine_command(ui_controller, agent, session_manager)
             next
@@ -1040,13 +1087,29 @@ module Clacky
             next
           end
 
+          queued = input_submission_mutex.synchronize do
+            if !force_interrupt && current_task_thread&.alive? && %w[queue steer].include?(agent_config.input_behavior)
+              agent.enqueue_input(input, delivery: agent_config.input_behavior.to_sym, files: files, created_at: Time.now.to_f)
+              true
+            end
+          end
+          next if queued
+
           # If any task thread is running, interrupt it first
           if current_task_thread&.alive?
             current_task_thread.raise(Clacky::AgentInterrupted, "New input received")
-            current_task_thread.join(2) # Wait up to 2 seconds for graceful shutdown
+            unless current_task_thread.join(2)
+              agent.enqueue_input(input, files: files, created_at: Time.now.to_f)
+              ui_controller.show_info("Current task is still stopping. Your message remains queued.")
+              next
+            end
             ui_controller.set_idle_status
           end
 
+          if force_interrupt
+            ui_controller.show_user_message(input, files: files, steering: true)
+          end
+
           # Cancel idle timer if running (new input means user is active)
           idle_timer.cancel
 
@@ -1061,14 +1124,19 @@ module Clacky
               # Run agent (Agent will call @ui methods directly)
               # Agent internally tracks total_tasks and total_cost
               result = agent.run(input, files: files)
-
-              # Save session after each task
-              if session_manager
-                session_manager.save(agent.to_session_data(status: :success, updated_at: Time.now))
+              loop do
+                if session_manager
+                  session_manager.save(agent.to_session_data(status: :success, updated_at: Time.now))
+                end
+                ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+                pending = input_submission_mutex.synchronize do
+                  entry = agent.take_pending_input if Agent.task_completed?(result)
+                  current_task_thread = nil unless entry
+                  entry
+                end
+                break unless pending
+                result = agent.run_pending_input(pending)
               end
-
-              # Update session bar with agent's cumulative stats
-              ui_controller.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
             rescue Clacky::AgentInterrupted, StandardError => e
               begin
                 handle_agent_exception(ui_controller, agent, session_manager, e)
@@ -1078,13 +1146,25 @@ module Clacky
                 $stderr.puts "[cli] handle_agent_exception failed: #{ex.class}: #{ex.message}"
               end
             ensure
-              current_task_thread = nil
-              # Start idle timer after agent completes
-              idle_timer.start unless shutting_down
+              input_submission_mutex.synchronize do
+                current_task_thread = nil if current_task_thread == Thread.current
+                idle_timer.start unless shutting_down || current_task_thread&.alive?
+              end
             end
           end
         end
 
+        ui_controller.on_input do |input, files, display: nil|
+          handle_input.call(input, files, display: display)
+        end
+        ui_controller.on_guidance_action do |action, id|
+          # Claim the displayed message once; an already-consumed ID is a no-op.
+          entry = agent.remove_pending_input(id)
+          if entry && action == :send_now
+            handle_input.call(entry[:content], entry.dig(:options, :files) || [], force_interrupt: true)
+          end
+        end if ui_controller.respond_to?(:on_guidance_action)
+
         # Initialize UI screen first
         if is_session_load
           recent_user_messages = agent.get_recent_user_messages(limit: 5)

data/lib/clacky/cli_guidance.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Clacky
+  # Pending guidance belongs to the fixed composer area, not the transcript.
+  module CliGuidance
+    def on_guidance_action(&block)
+      @guidance_action = block
+    end
+
+    def request_guidance_action(action)
+      entry = (@guidance_entries || []).last
+      return false unless entry && @guidance_action
+      dispatch_guidance_action(action, entry[:id])
+      true
+    end
+
+    def dispatch_guidance_action(action, id)
+      @guidance_action.call(action, id)
+    end
+
+    def guidance_control?(text)
+      text.to_s.match?(%r{\A/input-mode(?:\s|\z)})
+    end
+
+    def guidance_deferred?(text)
+      guidance_control?(text) || !!queue_input_while_running&.call
+    end
+
+    def guidance_lines
+      entries = @guidance_entries || []
+      return [] if entries.empty?
+
+      previews = entries.last(3).map do |entry|
+        text = entry[:content].to_s
+        if text.strip.empty?
+          text = Array(entry.dig(:options, :files)).map { |f| f[:name] || f["name"] }.compact.join(", ")
+        end
+        "  · #{text.gsub(/[[:cntrl:]]/, ' ').gsub(/\s+/, ' ').strip}"
+      end
+      ["Pending · Ctrl+D delete last · Ctrl+G send now", *(entries.size > 3 ? ["  … #{entries.size - 3} earlier"] : []), *previews]
+    end
+
+    def show_input_queue(entries)
+      @guidance_entries = entries
+      refresh_guidance if respond_to?(:refresh_guidance)
+    end
+  end
+end

data/lib/clacky/client.rb

@@ -720,12 +720,12 @@ module Clacky
           conn.headers["x-api-key"]      = @api_key
           conn.headers["anthropic-version"] = "2023-06-01"
           conn.headers["anthropic-dangerous-direct-browser-access"] = "true"
-          if @provider_id == "openrouter"
+          if @provider_id == Clacky::Providers::OPENROUTER_ID
             conn.headers["Authorization"] = "Bearer #{@api_key}"
           end
           # Moonshot's Kimi Code (Coding Plan) endpoint enforces a User-Agent
           # prefix whitelist limited to first-party coding agents.
-          if @provider_id == "kimi-coding"
+          if @provider_id == Clacky::Providers::KIMI_CODING_ID
             conn.headers["User-Agent"] = "claude-cli/1.0.51 (external, cli)"
           end
           conn.options.timeout      = @read_timeout || 300