openclacky 1.5.4 → 1.5.5

data/lib/clacky/providers.rb

@@ -477,6 +477,67 @@ module Clacky
         "website_url" => "https://console.volcengine.com/ark/region:cn-beijing/overview"
       }.freeze,
 
+      "ollama" => {
+        "name" => "Ollama (Cloud)",
+        # Ollama Cloud API — OpenAI-compatible endpoint serving both local and
+        # cloud models. Cloud models are available immediately without pulling.
+        # Authentication: API key via Authorization: Bearer <key> header.
+        # Create API keys at: https://ollama.com/settings/keys
+        "base_url" => "https://ollama.com",
+        "api" => "openai-completions",
+        "default_model" => "deepseek-v4-flash",
+        # Curated list of cloud-enabled models from the Ollama library.
+        # Users can type any Ollama model name manually; this list seeds the picker.
+        "models" => [
+          "glm-5.2",
+          "kimi-k3",
+          "gemma4",
+          "qwen3.5",
+          "glm-5.1",
+          "minimax-m2.7",
+          "nemotron-3-super",
+          "minimax-m3",
+          "kimi-k2.7-code",
+          "kimi-k2.6",
+          "deepseek-v4-flash",
+          "deepseek-v4-pro",
+          "nemotron-3-ultra",
+          "gemini-3-flash-preview",
+          "nemotron-3-nano",
+          "mistral-large-3",
+          "gpt-oss"
+        ],
+        # Provider-level default: many Ollama cloud models are vision-capable.
+        "capabilities" => { "vision" => true }.freeze,
+        # Model-level overrides: text-only models that don't accept image input.
+        "model_capabilities" => {
+          "glm-5.2"             => { "vision" => false }.freeze,
+          "glm-5.1"             => { "vision" => false }.freeze,
+          "minimax-m2.7"        => { "vision" => false }.freeze,
+          "deepseek-v4-pro"     => { "vision" => false }.freeze,
+          "deepseek-v4-flash"   => { "vision" => false }.freeze,
+          "nemotron-3-super"    => { "vision" => false }.freeze,
+          "nemotron-3-ultra"    => { "vision" => false }.freeze,
+          "nemotron-3-nano"     => { "vision" => false }.freeze,
+          "gpt-oss"             => { "vision" => false }.freeze
+        }.freeze,
+        # Per-primary lite pairing: subagents use smaller models for cheap/fast work.
+        "lite_models" => {
+          "glm-5.2"                => "glm-5.1",
+          "kimi-k3"                => "kimi-k2.6",
+          "gemma4"                 => "nemotron-3-nano",
+          "qwen3.5"                => "gemini-3-flash-preview",
+          "minimax-m3"             => "minimax-m2.7",
+          "kimi-k2.7-code"         => "kimi-k2.6",
+          "deepseek-v4-pro"        => "deepseek-v4-flash",
+          "mistral-large-3"        => "nemotron-3-nano",
+          "gpt-oss"                => "nemotron-3-nano",
+          "gemini-3-flash-preview"  => "nemotron-3-nano"
+        },
+        "default_ocr_model" => "kimi-k2.7-code",
+        "website_url" => "https://ollama.com/settings/keys"
+      }.freeze,
+
       "openai" => {
         "name" => "OpenAI (GPT)",
         "base_url" => "https://api.openai.com/v1",

data/lib/clacky/server/http_server.rb

@@ -217,6 +217,9 @@ module Clacky
         # Lazy: process-wide MCP registry. Created on first /api/mcp/:name access
         # so test setups that override Dir.home in before-hooks still work.
         @mcp_registry_mutex = Mutex.new
+        # Install jobs: job_id => { stage:, progress:, error:, done: }
+        @install_jobs       = {}
+        @install_jobs_mutex = Mutex.new
         # Access key authentication:
         # - localhost (127.0.0.1 / ::1) is always trusted; auth is skipped entirely.
         # - Any other bind address requires CLACKY_ACCESS_KEY env var.
@@ -370,10 +373,13 @@ module Clacky
 
         server.mount_proc("/") do |req, res|
           if req.path == "/" || req.path == "/index.html"
-            product_name = Clacky::BrandConfig.load.product_name || "OpenClacky"
+            brand        = Clacky::BrandConfig.load
+            product_name = brand.product_name || "OpenClacky"
+            logo_url     = brand.logo_url || "/logo_nav_dark.png"
             pure         = req.query["pure"] == "true"
             html = File.read(index_html_path)
                        .gsub("{{BRAND_NAME}}", product_name)
+                       .gsub("{{BRAND_LOGO_URL}}", logo_url)
                        .gsub("{{EXT_SCRIPTS}}", pure ? "" : self.send(:webui_ext_script_tags))
             res.status                = 200
             res["Content-Type"]       = "text/html; charset=utf-8"
@@ -493,7 +499,9 @@ module Clacky
           # Building/extracting a tar.gz of ~/.clacky can take a while.
           120
         elsif path == "/api/store/extension/install"
-          300
+          10  # now async — just spawns a thread and returns job_id immediately
+        elsif path == "/api/store/extension/install/status"
+          10
         else
           30
         end
@@ -560,9 +568,11 @@ module Clacky
         when ["GET",    "/api/store/skills"]          then api_store_skills(res)
         when ["GET",    "/api/store/extensions"]          then api_store_extensions(req, res)
         when ["GET",    "/api/store/extensions/brand"]   then api_store_extensions_brand(res)
+        when ["GET",    "/api/store/extensions/system"]   then api_store_extensions_system(res)
         when ["GET",    "/api/store/extensions/installed"] then api_store_extensions_installed(res)
         when ["GET",    "/api/store/extension"]       then api_store_extension_detail(req, res)
         when ["POST",   "/api/store/extension/install"]  then api_store_extension_install(req, res)
+        when ["GET",    "/api/store/extension/install/status"] then api_store_extension_install_status(req, res)
         when ["POST",   "/api/store/extension/disable"] then api_store_extension_disable(req, res)
         when ["POST",   "/api/store/extension/enable"]  then api_store_extension_enable(req, res)
         when ["DELETE", "/api/store/extension"]         then api_store_extension_uninstall(req, res)
@@ -2527,6 +2537,47 @@ module Clacky
         end
       end
 
+      # GET /api/store/extensions/system
+      #
+      # Returns only the builtin (system) extensions shipped with the gem.
+      def api_store_extensions_system(res)
+        result   = Clacky::ExtensionLoader.load_all
+        disabled = Clacky::ExtensionLoader.disabled_ids
+
+        hidden = %w[coding general ext-studio].to_set
+
+        extensions = Array(result&.containers).filter_map do |ext_id, container|
+          next unless container[:layer] == :builtin
+          next if hidden.include?(ext_id)
+
+          local_name   = container[:name].to_s.then { |n| n.empty? ? ext_id : n }
+          local_desc   = container.dig(:raw, "description").to_s
+          local_desc_zh = container.dig(:raw, "description_zh").to_s
+          local_author = container[:author].to_s
+          local_units  = units_from_container(container)
+          {
+            "id"              => ext_id,
+            "name"            => local_name,
+            "display_name"    => container.dig(:raw, "display_name") || local_name,
+            "display_name_zh" => container.dig(:raw, "display_name_zh"),
+            "slug"            => ext_id,
+            "version"         => container[:version],
+            "description"     => local_desc,
+            "description_zh"  => local_desc_zh,
+            "author"          => local_author,
+            "units"           => local_units,
+            "layer"           => "builtin",
+            "installed"       => true,
+            "removable"       => false,
+            "disabled"        => disabled.include?(ext_id),
+          }
+        end
+
+        json_response(res, 200, { ok: true, extensions: extensions })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # GET /api/store/extensions/installed
       #
       # Returns all locally installed extensions (all layers: builtin, installed,
@@ -2656,6 +2707,7 @@ module Clacky
           slug = ext["name"] || ext[:name] || ext["slug"] || ext[:slug]
           container = extension_container(slug)
           ext  = ext.merge(
+            "slug"              => slug,
             "installed"         => !container.nil?,
             "installed_version" => container&.dig(:version),
             "removable"         => container && container[:layer] == :installed,
@@ -2732,7 +2784,9 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
-      # DELETE /api/store/extension   body: { id: <slug> }
+      # POST /api/store/extension/install   body: { download_url:, name: }
+      # Starts an async install job and returns immediately with a job_id.
+      # Poll GET /api/store/extension/install/status?job_id=xxx for progress.
       def api_store_extension_install(req, res)
         body         = parse_json_body(req)
         download_url = body["download_url"].to_s.strip
@@ -2743,14 +2797,71 @@ module Clacky
           return
         end
 
-        Clacky::ExtensionPackager.install(download_url, force: true)
-        Clacky::ExtensionLoader.invalidate_cache!
-        Clacky::Telemetry.extension_install!(name) unless name.empty?
-        json_response(res, 200, { ok: true, name: name })
-      rescue Clacky::ExtensionPackager::Error => e
-        json_response(res, 422, { ok: false, error: e.message })
-      rescue StandardError => e
-        json_response(res, 500, { ok: false, error: e.message })
+        job_id = SecureRandom.hex(8)
+        @install_jobs_mutex.synchronize do
+          sweep_stale_install_jobs!
+          @install_jobs[job_id] = { stage: "downloading", progress: 0, error: nil, done: false, updated_at: Time.now }
+        end
+
+        Thread.new do
+          begin
+            on_progress = lambda do |info|
+              @install_jobs_mutex.synchronize do
+                @install_jobs[job_id] = info.merge(error: nil, done: false, updated_at: Time.now)
+              end
+            end
+            Clacky::ExtensionPackager.install(download_url, force: true, on_progress: on_progress)
+            Clacky::ExtensionLoader.invalidate_cache!
+            Clacky::Telemetry.extension_install!(name) unless name.empty?
+            @install_jobs_mutex.synchronize do
+              @install_jobs[job_id] = { stage: "done", progress: 100, error: nil, done: true, updated_at: Time.now }
+            end
+          rescue StandardError => e
+            @install_jobs_mutex.synchronize do
+              @install_jobs[job_id] = { stage: "error", progress: 0, error: e.message, done: true, updated_at: Time.now }
+            end
+          end
+        end
+
+        json_response(res, 200, { ok: true, job_id: job_id })
+      end
+
+      # GET /api/store/extension/install/status?job_id=xxx
+      def api_store_extension_install_status(req, res)
+        job_id = req.query["job_id"].to_s.strip
+        if job_id.empty?
+          json_response(res, 400, { ok: false, error: "Missing job_id." })
+          return
+        end
+        job = @install_jobs_mutex.synchronize do
+          sweep_stale_install_jobs!
+          @install_jobs[job_id]
+        end
+        if job.nil?
+          json_response(res, 404, { ok: false, error: "Job not found." })
+          return
+        end
+        # Clean up finished jobs after they are read as done
+        if job[:done]
+          @install_jobs_mutex.synchronize { @install_jobs.delete(job_id) }
+        end
+        json_response(res, 200, { ok: true }.merge(job))
+      end
+
+      # Install jobs can go stale in two ways:
+      #   - the client abandons the poll (tab closed, network drop) so a
+      #     finished job never gets picked up and deleted by the status endpoint
+      #   - the worker thread dies without ever updating the job hash (should
+      #     not happen given the rescue in api_store_extension_install, but a
+      #     hung Thread with no timeout upstream would otherwise pin memory
+      #     forever)
+      # Sweep anything past its TTL. Must be called from inside
+      # @install_jobs_mutex.synchronize.
+      INSTALL_JOB_TTL = 30 * 60 # seconds
+
+      private def sweep_stale_install_jobs!
+        cutoff = Time.now - INSTALL_JOB_TTL
+        @install_jobs.delete_if { |_id, job| (job[:updated_at] || Time.at(0)) < cutoff }
       end
 
       def api_store_extension_uninstall(req, res)
@@ -4354,12 +4465,30 @@ module Clacky
       # Each entry carries { id, title, title_zh, description, description_zh,
       # source, order, layer, author }. Extensions can supply title_zh /
       # description_zh / author in their ext.yml so the New Session cards read
-      # naturally and credit their author.
+      # naturally and credit their author. Third-party extension agents are
+      # ordered by most-recently-used (derived from session history) so the
+      # ones the user actually uses float to the front of that group.
       def api_list_agents(res)
-        agents = Clacky::AgentProfile.all
+        recency = agent_last_used_recency
+        agents = Clacky::AgentProfile.all(recency: recency)
         json_response(res, 200, { agents: agents })
       end
 
+      # Map agent_profile id => most recent session's updated_at (epoch seconds),
+      # scanning every session on disk. Used to rank extension agent cards by
+      # recent usage instead of a static declared `order`.
+      private def agent_last_used_recency
+        recency = {}
+        @session_manager.all_sessions.each do |s|
+          id = (s[:agent_profile] || "general").to_s
+          ts = s[:updated_at] || s[:created_at]
+          next unless ts
+          epoch = Time.parse(ts.to_s).to_i rescue next
+          recency[id] = epoch if epoch > (recency[id] || 0)
+        end
+        recency
+      end
+
       # GET /api/sessions/:id/skills — list user-invocable skills for a session,
       # filtered by the session's agent profile. Used by the frontend slash-command
       # autocomplete so only skills valid for the current profile are suggested.
@@ -5667,6 +5796,7 @@ module Clacky
         json_response(res, 200, {
           ok: true,
           enable_compression: @agent_config.enable_compression,
+          enable_idle_compression: @agent_config.enable_idle_compression,
           enable_prompt_caching: @agent_config.enable_prompt_caching,
           memory_update_enabled: @agent_config.memory_update_enabled,
           proxy_url: @agent_config.proxy_url.to_s,
@@ -5692,6 +5822,9 @@ module Clacky
         if body.key?("enable_compression")
           @agent_config.enable_compression = !!body["enable_compression"]
         end
+        if body.key?("enable_idle_compression")
+          @agent_config.enable_idle_compression = !!body["enable_idle_compression"]
+        end
         if body.key?("enable_prompt_caching")
           @agent_config.enable_prompt_caching = !!body["enable_prompt_caching"]
         end
@@ -6264,7 +6397,7 @@ module Clacky
       end
 
       # PATCH /api/sessions/:id/reasoning_effort
-      # Body: { "reasoning_effort": "off" | "low" | "medium" | "high" | "xhigh" }
+      # Body: { "reasoning_effort": "off" | "low" | "medium" | "high" | "xhigh" | "max" }
       def api_switch_session_reasoning_effort(session_id, req, res)
         body = parse_json_body(req)
         raw = body["reasoning_effort"]
@@ -6766,7 +6899,13 @@ module Clacky
         msg_created_at = Time.now.to_f
         web_ui = nil
         @registry.with_session(session_id) { |s| web_ui = s[:ui] }
-        web_ui&.show_user_message(content, created_at: msg_created_at, source: :web)
+        # Pass the uploaded files through to the realtime broadcast so images and
+        # attachments render in the bubble immediately. agent.run later appends the
+        # authoritative display_files to history — but only after vision/OCR
+        # processing finishes, which can take seconds. Without the preview here, a
+        # page refresh inside that window shows the message without its image (the
+        # "need to refresh several times before the image appears" bug).
+        web_ui&.show_user_message(content, created_at: msg_created_at, source: :web, files: Array(files))
 
         # File references are now handled inside agent.run — injected as a system_injected
         # message after the user message, so replay_history skips them automatically.

data/lib/clacky/server/web_ui_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cgi"
 require "json"
 require "securerandom"
 require_relative "../ui_interface"
@@ -70,11 +71,20 @@ module Clacky
         data[:created_at] = created_at if created_at
         # Build ev.images for the frontend renderer (history_user_message):
         #   - Images with data_url → pass the data_url directly (<img> thumbnail)
-        #   - Disk files (PDF, doc, etc., no data_url) → "pdf:name" sentinel (renders a badge)
+        #   - Disk image files (type=="image", has path) → /api/local-image proxy URL
+        #   - Disk files (PDF, doc, etc., no data_url, no image path) → "pdf:name" sentinel
         rendered = Array(files).filter_map do |f|
           url  = f[:data_url] || f["data_url"]
           name = f[:name]     || f["name"]
-          url || (name ? "pdf:#{name}" : nil)
+          type = f[:type]     || f["type"]
+          path = f[:path]     || f["path"]
+          if url
+            url
+          elsif type.to_s == "image" && path && File.exist?(path.to_s)
+            "/api/local-image?path=#{CGI.escape(path.to_s)}&v=#{File.mtime(path.to_s).to_i}"
+          elsif name
+            "pdf:#{name}"
+          end
         end
         data[:images] = rendered unless rendered.empty?
         emit("history_user_message", **data)

data/lib/clacky/session_manager.rb

@@ -36,6 +36,7 @@ module Clacky
       # Keep only the most recent 200 sessions (best-effort, never block save)
       begin
         cleanup_by_count(keep: 200, keep_cron: 200)
+        cleanup_trash(days: 8)
       rescue Exception # rubocop:disable Lint/RescueException
         # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
       end

data/lib/clacky/tools/terminal.rb

@@ -480,9 +480,7 @@ module Clacky
           # leaves the result as invalid UTF-8. Re-scrub after truncation so
           # everything downstream (JSON.generate, format_result, UI) gets a
           # guaranteed-valid UTF-8 string.
-          preview = cleaned.byteslice(0, OVERFLOW_PREVIEW_CHARS)
-          preview.force_encoding(Encoding::UTF_8)
-          preview = preview.scrub("?") unless preview.valid_encoding?
+          preview = smart_truncate(cleaned, OVERFLOW_PREVIEW_CHARS)
 
           notice = if overflow_file
             "\n\n...[Output truncated for LLM: showing first #{OVERFLOW_PREVIEW_CHARS} " \
@@ -1429,6 +1427,35 @@ module Clacky
         nil
       end
 
+      # Smart truncation: keep head + tail within char budget.
+      # Ensures error messages at end of output remain visible.
+      private def smart_truncate(text, max_chars)
+        total_chars = text.bytesize
+        return text if total_chars <= max_chars
+
+        total_lines = text.lines.count
+
+        # 60% head, 40% tail
+        head_budget = (max_chars * 0.6).to_i
+        tail_budget = max_chars - head_budget
+
+        head = text.byteslice(0, head_budget)
+        head.force_encoding(Encoding::UTF_8)
+        head = head.scrub("?") unless head.valid_encoding?
+
+        tail = text.byteslice(-tail_budget, tail_budget)
+        tail.force_encoding(Encoding::UTF_8)
+        tail = tail.scrub("?") unless tail.valid_encoding?
+
+        # Align tail to line boundary if cut mid-line
+        if tail.include?("\n") && !tail.start_with?("\n")
+          first_nl = tail.index("\n")
+          tail = tail[(first_nl + 1)..-1] || ""
+        end
+
+        "#{head}\n\n...[#{total_lines} lines, #{total_chars} chars total, truncated]...\n\n#{tail}"
+      end
+
 
 
       # Max visible length of a command inside the tool-call summary line.

data/lib/clacky/version.rb

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