openclacky 1.3.3 → 1.3.5

data/lib/clacky/api_extension_loader.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Clacky
+  # Discovers and loads user-defined HTTP API extensions from
+  # ~/.clacky/api_ext/<name>/handler.rb. Each handler is expected to define a
+  # subclass of Clacky::ApiExtension; the subclass is auto-registered with the
+  # framework and its routes become available under /api/ext/<name>/.
+  #
+  # A broken extension (syntax error, missing base class, route conflict) is
+  # isolated: skipped with a logged warning, never aborts the load of others.
+  module ApiExtensionLoader
+    DEFAULT_DIR  = File.expand_path("~/.clacky/api_ext")
+    BUILTIN_DIR  = File.expand_path("../default_extensions", __FILE__)
+    DISABLED_DIR = "_disabled"
+
+    Result = Struct.new(:loaded, :skipped, keyword_init: true)
+
+    class << self
+      def load_all(dir: DEFAULT_DIR, builtin: true)
+        result = Result.new(loaded: [], skipped: [])
+        Clacky::ApiExtension.reset_registry!
+
+        # Load built-in (gem-shipped) extensions first (lowest priority)
+        if builtin && Dir.exist?(BUILTIN_DIR)
+          Dir.glob(File.join(BUILTIN_DIR, "*", "handler.rb")).sort.each do |handler_path|
+            ext_dir = File.dirname(handler_path)
+            ext_id  = File.basename(ext_dir)
+            next if ext_id.start_with?("_")
+            load_one(ext_id, ext_dir, handler_path, result)
+          end
+        end
+
+        # Load user extensions (higher priority — same ext_id overwrites built-in)
+        if Dir.exist?(dir)
+          Dir.glob(File.join(dir, "*", "handler.rb")).sort.each do |handler_path|
+            ext_dir = File.dirname(handler_path)
+            ext_id  = File.basename(ext_dir)
+            next if ext_id == DISABLED_DIR || ext_id.start_with?("_")
+            load_one(ext_id, ext_dir, handler_path, result)
+          end
+        end
+
+        @last_result = result
+        log_summary(result)
+        result
+      end
+
+      def last_result
+        @last_result || load_all
+      end
+
+      def load_one(ext_id, ext_dir, handler_path, result)
+        meta = read_meta(ext_dir)
+        before = Clacky::ApiExtension.pending_subclasses.size
+
+        require handler_path
+
+        new_subclasses = Clacky::ApiExtension.pending_subclasses[before..] || []
+        klass = new_subclasses.last
+
+        unless klass
+          result.skipped << [ext_id, "no Clacky::ApiExtension subclass defined in handler.rb"]
+          log_skip(ext_id, result.skipped.last[1])
+          return
+        end
+
+        klass.ext_id  = ext_id
+        klass.ext_dir = ext_dir
+        klass.meta    = meta
+
+        if klass.routes.empty?
+          result.skipped << [ext_id, "no routes declared (use get/post/... DSL)"]
+          log_skip(ext_id, result.skipped.last[1])
+          Clacky::ApiExtension.registry.delete(ext_id)
+          return
+        end
+
+        if (gap = validate_public_endpoints(klass, meta))
+          result.skipped << [ext_id, gap]
+          log_skip(ext_id, gap)
+          return
+        end
+
+        Clacky::ApiExtension.register(ext_id, klass)
+        result.loaded << ext_id
+        public_count = klass.public_paths.size
+        suffix = public_count > 0 ? " (#{public_count} public)" : ""
+        Clacky::Logger.info("[ApiExtensionLoader] Loaded '#{ext_id}' — #{klass.routes.size} route(s)#{suffix}")
+      rescue StandardError, ScriptError => e
+        result.skipped << [ext_id, e.message]
+        log_skip(ext_id, e.message)
+      end
+
+      private def read_meta(ext_dir)
+        path = File.join(ext_dir, "meta.yml")
+        return {} unless File.exist?(path)
+
+        YAMLCompat.load_file(path) || {}
+      rescue StandardError => e
+        Clacky::Logger.warn("[ApiExtensionLoader] Failed to read meta.yml in #{ext_dir}: #{e.message}")
+        {}
+      end
+
+      private def validate_public_endpoints(klass, meta)
+        return nil if klass.public_paths.empty?
+        return nil if meta["public"] == true
+
+        "uses public_endpoint but meta.yml is missing 'public: true'"
+      end
+
+      private def log_skip(ext_id, reason)
+        Clacky::Logger.warn("[ApiExtensionLoader] Skipped '#{ext_id}': #{reason}")
+      end
+
+      private def log_summary(result)
+        return if result.loaded.empty? && result.skipped.empty?
+
+        total_routes = result.loaded.sum { |id| Clacky::ApiExtension.registry[id]&.routes&.size || 0 }
+        Clacky::Logger.info("[ApiExtensionLoader] #{result.loaded.size} extension(s), #{total_routes} route(s); #{result.skipped.size} skipped")
+      end
+
+      # Generate a starter handler.rb at ~/.clacky/api_ext/<name>/handler.rb.
+      # Returns the path to the generated file.
+      def scaffold(name, dir: DEFAULT_DIR)
+        slug = name.to_s.strip.downcase.gsub(/[^a-z0-9_-]+/, "-").gsub(/\A-+|-+\z/, "")
+        raise ArgumentError, "invalid api_ext name: #{name.inspect}" if slug.empty?
+
+        target_dir = File.join(dir, slug)
+        path = File.join(target_dir, "handler.rb")
+        raise ArgumentError, "api_ext already exists: #{path}" if File.exist?(path)
+
+        FileUtils.mkdir_p(target_dir)
+        File.write(path, skeleton(slug))
+        path
+      end
+
+      private def skeleton(slug)
+        const = slug.split(/[-_]/).map(&:capitalize).join + "Ext"
+        <<~RUBY
+          # frozen_string_literal: true
+
+          # Custom HTTP API extension mounted at /api/ext/#{slug}/
+          # Scaffolded by `clacky api_ext_new #{slug}` — fill in the routes you need.
+          class #{const} < Clacky::ApiExtension
+            get "/hello" do
+              json(message: "hello from #{slug}")
+            end
+
+            # Examples — uncomment and adapt:
+            #
+            # post "/items" do
+            #   body = json_body
+            #   error!("name required", status: 422) unless body["name"]
+            #   File.write(data_path("items.json"), body.to_json)
+            #   json(ok: true)
+            # end
+            #
+            # get "/items/:id" do
+            #   json(id: params[:id])
+            # end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/clacky/cli.rb

@@ -268,8 +268,9 @@ module Clacky
           config.save
         end
 
-        # Refresh UI bar
+        # Refresh UI bar and model list
         ui_controller.config[:model] = config.model_name
+        ui_controller.available_models = config.model_names
         ui_controller.update_sessionbar(
           tasks: agent.total_tasks,
           cost: agent.total_cost
@@ -836,11 +837,12 @@ module Clacky
             say "Error: Rich UI requires Ruby >= 2.6. Use --ui ui2 on Ruby #{RUBY_VERSION}.", :red
             exit 1
           end
-          require_relative "rich_ui_controller"
+          require_relative "rich_ui"
           RichUIController.new(
             working_dir: working_dir,
             mode: agent_config.permission_mode.to_s,
             model: agent_config.model_name,
+            model_names: agent_config.model_names,
             theme: options[:theme]
           )
         else
@@ -901,6 +903,21 @@ module Clacky
           agent_config.permission_mode = new_mode.to_sym
         end
 
+        # Set up model switch handler (from /model slash command)
+        ui_controller.on_model_switch do |model, persist|
+          next unless agent_config.switch_model_by_name(model)
+
+          id = agent_config.current_model_id
+          agent.switch_model_by_id(id)
+          if persist
+            agent_config.set_default_model_by_id(id)
+            agent_config.save
+            ui_controller.show_success("Model switched to #{model} (saved)")
+          else
+            ui_controller.show_success("Model switched to #{model} (session only)")
+          end
+        end
+
         # Set up time machine handler (ESC key)
         ui_controller.on_time_machine do
           handle_time_machine_command(ui_controller, agent, session_manager)
@@ -921,6 +938,16 @@ module Clacky
           end
 
           if (not current_task_thread&.alive?) && input_was_empty
+            # Rich UI: require double-tap Ctrl+C to exit.  When the user
+            # just copied terminal-native text selection, the viewport
+            # has no knowledge of the selection, yet Ctrl+C must not exit.
+            # First press only sets the warning; second press exits.
+            if ui_controller.respond_to?(:ctrl_c_warning) && !ui_controller.ctrl_c_warning
+              ui_controller.instance_variable_set(:@ctrl_c_warning, "Press Ctrl+C again to exit")
+              ui_controller.set_input_tips("Press Ctrl+C again to exit.", type: :info)
+              next
+            end
+
             # Save final session state before exit
             if session_manager && agent.total_tasks > 0
               session_data = agent.to_session_data(status: :exited)
@@ -1038,7 +1065,13 @@ module Clacky
               # 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
-              handle_agent_exception(ui_controller, agent, session_manager, e)
+              begin
+                handle_agent_exception(ui_controller, agent, session_manager, e)
+              rescue StandardError => ex
+                # If handle_agent_exception itself raises (e.g. UI in bad state),
+                # prevent the thread from dying with an unhandled exception.
+                $stderr.puts "[cli] handle_agent_exception failed: #{ex.class}: #{ex.message}"
+              end
             ensure
               current_task_thread = nil
               # Start idle timer after agent completes
@@ -1181,6 +1214,63 @@ module Clacky
       exit 1 if result.skipped.any?
     end
 
+    desc "api_ext_new NAME", "Scaffold a custom HTTP API extension at ~/.clacky/api_ext/NAME/"
+    long_desc <<-LONGDESC
+      Generate a ready-to-edit HTTP API extension skeleton. The skeleton mounts
+      a sample route under /api/ext/NAME/ — fill in your routes, then verify with
+      `clacky api_ext_verify`.
+
+      Examples:
+        $ clacky api_ext_new my-dashboard
+    LONGDESC
+    def api_ext_new(name)
+      path = Clacky::ApiExtensionLoader.scaffold(name)
+      puts "Created api extension: #{path}"
+      puts "Edit the routes, then run: clacky api_ext_verify"
+    rescue ArgumentError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    desc "api_ext_verify", "Load user API extensions and report which are valid"
+    def api_ext_verify
+      result = Clacky::ApiExtensionLoader.load_all
+
+      if result.loaded.empty? && result.skipped.empty?
+        puts "No api extensions found in ~/.clacky/api_ext/"
+        return
+      end
+
+      result.loaded.each do |id|
+        klass = Clacky::ApiExtension.registry[id]
+        public_count = klass.public_paths.size
+        suffix = public_count > 0 ? " (#{public_count} public)" : ""
+        puts "[OK]   #{id} — #{klass.routes.size} route(s)#{suffix}"
+      end
+      result.skipped.each { |(n, reason)| puts "[SKIP] #{n} — #{reason}" }
+      exit 1 if result.skipped.any?
+    end
+
+    desc "api_ext_list", "List loaded API extensions and their routes"
+    def api_ext_list
+      Clacky::ApiExtensionLoader.load_all if Clacky::ApiExtension.registry.empty?
+
+      if Clacky::ApiExtension.registry.empty?
+        puts "No api extensions loaded."
+        return
+      end
+
+      Clacky::ApiExtension.registry.each do |id, klass|
+        public_tag = klass.public_paths.any? ? " (public)" : ""
+        puts "#{id}#{public_tag}"
+        klass.routes.each do |route|
+          full_path = "/api/ext/#{id}#{route.pattern}".chomp("/")
+          full_path = "/api/ext/#{id}/" if full_path == "/api/ext/#{id}"
+          puts "  #{route.method.to_s.upcase.ljust(6)} #{full_path}"
+        end
+      end
+    end
+
     desc "billing", "Show billing summary and usage statistics"
     long_desc <<-LONGDESC
       Display billing summary with token usage and cost breakdown.

data/lib/clacky/client.rb

@@ -34,11 +34,6 @@ module Clacky
       # some OpenRouter-compatible relays only honour Bearer — send both).
       @provider_id = provider_id
 
-      # Determine vision support once at construction time.
-      # Non-vision models (DeepSeek, Kimi, MiniMax, etc.) reject image_url
-      # content blocks; the conversion layer strips them when this is false.
-      @vision_supported = Providers.supports?(provider_id, :vision, model_name: @model)
-
       # Optional override for Faraday read_timeout (e.g. benchmark calls).
       # nil means use the default (300s for streaming).
       @read_timeout = read_timeout
@@ -343,9 +338,12 @@ module Clacky
       # OpenRouter proxies Claude with the same cache_control field convention as Anthropic direct.
       messages = apply_message_caching(messages) if caching_enabled
 
+      # Vision support is resolved against the request's actual model (which may
+      # differ from @model after a runtime switch or fallback override), so the
+      # conversion layer strips image_url blocks for non-vision models.
       body = MessageFormat::OpenAI.build_request_body(
         messages, model, tools, max_tokens, caching_enabled,
-        vision_supported: @vision_supported,
+        vision_supported: Providers.supports?(@provider_id, :vision, model_name: model),
         reasoning_effort: reasoning_effort
       )
       return send_openai_stream_request(body, on_chunk) if on_chunk
@@ -515,6 +513,12 @@ module Clacky
       end
     end
 
+    def reset_connections!
+      @bedrock_connection = nil
+      @openai_connection = nil
+      @anthropic_connection = nil
+    end
+
     def bedrock_connection
       current_epoch = Clacky::ProxyConfig.epoch
       if @bedrock_connection.nil? ||
@@ -598,11 +602,24 @@ module Clacky
       return { success: true, status: response.status } if response.status == 200
 
       error_body = JSON.parse(response.body) rescue nil
+      error_code = extract_error_code(error_body)
+
+      translated = case response.status
+      when 402       then I18n.t("llm.error.insufficient_credit")
+      when 400       then I18n.t("llm.error.rate_limit_400")
+      when 401       then I18n.t("llm.error.invalid_api_key")
+      when 403       then I18n.t("llm.error.403.#{error_code || "default"}")
+      when 404       then I18n.t("llm.error.endpoint_not_found")
+      when 429       then I18n.t("llm.error.rate_limit_429")
+      when 500..599  then I18n.t("llm.error.server_error", status: response.status)
+      else                extract_error_message(error_body, response.body)
+      end
+
       {
         success:    false,
         status:     response.status,
-        error:      extract_error_message(error_body, response.body),
-        error_code: extract_error_code(error_body)
+        error:      translated,
+        error_code: error_code
       }
     end
 
@@ -620,31 +637,36 @@ module Clacky
 
       if error_code == "insufficient_credit" || response.status == 402
         raise InsufficientCreditError.new(
-          "[LLM] Insufficient credit: #{error_message}",
+          "[LLM] #{I18n.t("llm.error.insufficient_credit")}",
           error_code: "insufficient_credit",
-          provider_id: @provider_id
+          provider_id: @provider_id,
+          raw_message: error_message
         )
       end
 
       case response.status
       when 400
-        # Well-behaved APIs (Anthropic, OpenAI) never put quota/availability issues in 400.
-        # However, some proxy/relay providers do — so we inspect the message first.
-        # Also, Bedrock returns ThrottlingException as 400 instead of 429.
         if error_message.match?(/ThrottlingException|unavailable|quota/i)
-          hint = error_message.match?(/quota/i) ? " (possibly out of credits)" : ""
-          raise RetryableError, "[LLM] Rate limit or service issue: #{error_message}#{hint}"
+          raise RetryableError, "[LLM] #{I18n.t("llm.error.rate_limit_400")}"
         end
 
-        # True bad request — our message was malformed. Roll back history so the
-        # broken message is not replayed on the next user turn.
-        raise BadRequestError, "[LLM] Client request error: #{error_message}"
-      when 401 then raise AgentError, "[LLM] Invalid API key"
-      when 403 then raise AgentError, "[LLM] Access denied: #{error_message}"
-      when 404 then raise AgentError, "[LLM] API endpoint not found: #{error_message}"
-      when 429 then raise RetryableError, "[LLM] Rate limit exceeded, please wait a moment"
-      when 500..599 then raise RetryableError, "[LLM] Service temporarily unavailable (#{response.status}), retrying..."
-      else raise AgentError, "[LLM] Unexpected error (#{response.status}): #{error_message}"
+        raise BadRequestError.new(
+          "[LLM] Client request error: #{error_message}",
+          display_message: "[LLM] #{I18n.t("llm.error.bad_request")}",
+          raw_message: error_message
+        )
+      when 401
+        raise AgentError.new("[LLM] #{I18n.t("llm.error.invalid_api_key")}", raw_message: error_message)
+      when 403
+        i18n_key = "llm.error.403.#{error_code}"
+        translated = I18n.t(i18n_key)
+        translated = I18n.t("llm.error.403.default") if translated == i18n_key
+        raise AgentError.new("[LLM] #{translated}", raw_message: error_message)
+      when 404
+        raise AgentError.new("[LLM] #{I18n.t("llm.error.endpoint_not_found")}", raw_message: error_message)
+      when 429 then raise RetryableError, "[LLM] #{I18n.t("llm.error.rate_limit_429")}"
+      when 500..599 then raise RetryableError, "[LLM] #{I18n.t("llm.error.server_error", status: response.status)}"
+      else raise AgentError.new("[LLM] #{I18n.t("llm.error.unexpected", status: response.status)}", raw_message: error_message)
       end
     end
 
@@ -652,7 +674,7 @@ module Clacky
     def check_html_response(response)
       body = response.body.to_s.lstrip
       if body.start_with?("<!DOCTYPE", "<!doctype", "<html", "<HTML")
-        raise RetryableError, "[LLM] Service temporarily unavailable (received HTML error page), retrying..."
+        raise RetryableError, "[LLM] #{I18n.t("llm.error.html_response")}"
       end
     end
 

data/lib/clacky/default_agents/_panels/git/panel.js

@@ -196,6 +196,6 @@
   }, {
     panel: "git",
     order: 10,
-    tab: { id: "changes", label: (typeof I18n !== "undefined" ? (I18n.t("changes.tab") !== "changes.tab" ? I18n.t("changes.tab") : "Git 管理") : "Git 管理") },
+    tab: { id: "changes", label: () => t("changes.tab") },
   });
 })();

data/lib/clacky/default_agents/_panels/time_machine/panel.js

@@ -19,6 +19,25 @@
 (() => {
   if (!window.Clacky || !Clacky.ext) return;
 
+  // The currently mounted panel's state, refreshed on every mount. A single WS
+  // hook (registered once below) reloads it when the active session completes a
+  // task, so new snapshots appear without a manual refresh. Kept as a closure
+  // singleton because WS.onEvent has no unsubscribe and the panel re-mounts on
+  // each session switch.
+  let _activeState = null;
+  let _wsHooked = false;
+
+  function _hookWs() {
+    if (_wsHooked || typeof WS === "undefined") return;
+    _wsHooked = true;
+    WS.onEvent((ev) => {
+      if (ev && ev.type === "complete" && _activeState &&
+          ev.session_id === _activeState.sessionId) {
+        loadHistory(_activeState);
+      }
+    });
+  }
+
   const t = (k, fallback) => {
     const v = (typeof I18n !== "undefined") ? I18n.t(k) : null;
     return (v && v !== k) ? v : fallback;
@@ -630,11 +649,14 @@
     d.mask.onclick = onMaskClick;
     document.addEventListener("keydown", onKey);
 
+    _activeState = state;
+    _hookWs();
+
     loadHistory(state);
     return root;
   }, {
     panel: "time_machine",
     order: 20,
-    tab: { id: "tm", label: t("tm.tab", "时光机") },
+    tab: { id: "tm", label: () => t("tm.tab") },
   });
 })();

data/lib/clacky/default_agents/base_prompt.md

@@ -9,6 +9,7 @@
 
 - **ALWAYS use `glob` tool to find files — NEVER use shell `find` command for file discovery**
 - **All operations default to the working directory** (shown in session context)
+- **NEVER write tool calls as text** (e.g. `<invoke name=...>`, `<function_calls>`). Use the structured tool_calls field — text won't execute.
 
 ## Response Style