openclacky 1.5.21 → 1.5.22

data/lib/clacky/server/web_ui_controller.rb

@@ -20,7 +20,7 @@ module Clacky
         @broadcaster.call(@session_id, { type: "input_queue", session_id: @session_id, entries: entries })
       end
 
-      attr_reader :session_id
+      attr_reader :session_id, :last_complete
 
       def initialize(session_id, broadcaster)
         @session_id  = session_id
@@ -70,23 +70,24 @@ module Clacky
 
       # Use the same contract as the CLI. The server owns the deadline;
       # typing cancels automatic continuation but keeps the answer wait alive.
+      # Leaving auto mode ends the countdown like an intervention, so the task
+      # finishes as awaiting_feedback instead of blocking while marked running.
       def request_feedback_with_countdown(seconds: 20)
         pending = { id: @feedback_request_id || SecureRandom.uuid, cond: ConditionVariable.new,
                     deadline_ms: (Time.now.to_f * 1000).to_i + seconds * 1000 }
-        pending[:seconds] = seconds
         pending[:deadline] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
         @mutex.synchronize do
-          pending[:manual] = @feedback_permission_mode == :confirm_all
+          return :intervened if @feedback_permission_mode == :confirm_all
           @pending_feedback = pending
         end
-        emit("feedback_countdown", request_id: pending[:id], deadline_ms: pending[:manual] ? nil : pending[:deadline_ms])
+        emit("feedback_countdown", request_id: pending[:id], deadline_ms: pending[:deadline_ms])
         @mutex.synchronize do
           until pending[:result]
             remaining = pending[:deadline] - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-            if !pending[:manual] && remaining <= 0
+            if remaining <= 0
               pending[:result] = :timeout
             else
-              pending[:cond].wait(@mutex, pending[:manual] ? nil : remaining)
+              pending[:cond].wait(@mutex, remaining)
             end
           end
           pending[:result]
@@ -105,21 +106,14 @@ module Clacky
       end
 
       def update_permission_mode(mode)
-        countdown = @mutex.synchronize do
+        @mutex.synchronize do
           @feedback_permission_mode = mode.to_sym
           pending = @pending_feedback
-          if pending && !pending[:result]
-            if mode.to_sym == :auto_approve && pending[:manual]
-              pending[:deadline] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + pending[:seconds]
-              pending[:deadline_ms] = (Time.now.to_f * 1000).to_i + pending[:seconds] * 1000
-            end
-            pending[:manual] = mode.to_sym != :auto_approve
+          if pending && !pending[:result] && mode.to_sym != :auto_approve
+            pending[:result] = :intervened
             pending[:cond].signal
-            { request_id: pending[:id],
-              deadline_ms: pending[:manual] ? nil : pending[:deadline_ms] }
           end
         end
-        emit("feedback_countdown", **countdown) if countdown
       end
 
       def intervene_feedback(request_id)
@@ -142,24 +136,37 @@ module Clacky
         data[:skill_command] = skill_command if skill_command
         data[:skill_command_display] = skill_command_display if skill_command_display
         data[:references] = Array(references) unless Array(references).empty?
-        # Build ev.images for the frontend renderer (history_user_message):
-        #   - Images with data_url → pass the data_url directly (<img> thumbnail)
-        #   - 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|
+        # Images keep using the lightbox renderer. Other attachments carry their
+        # path separately so the browser can open them through the Files viewer.
+        # A missing path is deliberately omitted: the card remains visible but
+        # is no longer presented as an actionable control.
+        rendered_images = []
+        rendered_attachments = []
+        Array(files).each do |f|
+          next if f[:reference] || f["reference"]
+
           url  = f[:data_url] || f["data_url"]
           name = f[:name]     || f["name"]
           type = f[:type]     || f["type"]
           path = f[:path]     || f["path"]
+          mime = f[:mime_type] || f["mime_type"]
+          image = type.to_s == "image" || mime.to_s.start_with?("image/")
+
           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}"
+            rendered_images << url
+          elsif image && path && File.exist?(path.to_s)
+            rendered_images << "/api/local-image?path=#{CGI.escape(path.to_s)}&v=#{File.mtime(path.to_s).to_i}"
+          elsif image && name
+            rendered_images << "expired:#{name}"
           elsif name
-            "pdf:#{name}"
+            attachment_type = type.to_s.empty? ? (mime || "file") : type
+            attachment = { name: name, type: attachment_type }
+            attachment[:path] = path if path && File.exist?(path.to_s)
+            rendered_attachments << attachment
           end
         end
-        data[:images] = rendered unless rendered.empty?
+        data[:images] = rendered_images unless rendered_images.empty?
+        data[:attachments] = rendered_attachments unless rendered_attachments.empty?
         emit("history_user_message", **data)
         # Only forward to channel subscribers when the message originated from the WebUI,
         # to avoid echoing channel messages back to the same channel.
@@ -270,6 +277,7 @@ module Clacky
         data[:cache_stats]            = cache_stats         if cache_stats
         data[:awaiting_user_feedback] = awaiting_user_feedback if awaiting_user_feedback
         data[:cost_source]            = cost_source.to_s   if cost_source
+        @last_complete = data
         emit("complete", **data)
         forward_to_subscribers do |sub|
           sub.show_complete(iterations: iterations, cost: cost, duration: duration,
@@ -405,7 +413,7 @@ module Clacky
       def replay_live_state
         countdown = @mutex.synchronize do
           pending = @pending_feedback
-          pending ? { request_id: pending[:id], deadline_ms: pending[:manual] ? nil : pending[:deadline_ms] } : { resolved: true }
+          pending ? { request_id: pending[:id], deadline_ms: pending[:deadline_ms] } : { resolved: true }
         end
         emit("feedback_countdown", **countdown)
         return unless @live_progress_state

data/lib/clacky/session_manager.rb

@@ -20,8 +20,16 @@ module Clacky
       SecureRandom.hex(8)
     end
 
+    # How long a parsed session list is shared between callers, in seconds.
+    # Only meant to cover the burst of requests the first paint fires; see
+    # #load_all_sessions.
+    LIST_REUSE_WINDOW = 2.0
+
     def initialize(sessions_dir: nil)
       @sessions_dir = sessions_dir || SESSIONS_DIR
+      @recent_list    = nil
+      @recent_list_at = 0.0
+      @list_mutex     = Mutex.new
       ensure_sessions_dir
     end
 
@@ -34,6 +42,7 @@ module Clacky
       FileUtils.chmod(0o600, filepath)
 
       @last_saved_path = filepath
+      @recent_list_at  = 0.0
 
       run_cleanup_async
 
@@ -213,10 +222,12 @@ module Clacky
     # Optional filters:
     #   current_dir: (String) if given, sessions matching working_dir come first
     #   limit:       (Integer) max number of sessions to return
+    #
+    # Parsing every session file costs ~160ms for a few hundred sessions, and the
+    # first paint asks for this list from several endpoints at once, so the
+    # concurrent requests share a single scan (see #load_all_sessions).
     def all_sessions(current_dir: nil, limit: nil)
-      sessions = Dir.glob(File.join(@sessions_dir, "*.json")).filter_map do |filepath|
-        load_session_file(filepath)
-      end.sort_by { |s| [s[:updated_at] || s[:created_at] || "", s[:session_id].to_s] }.reverse
+      sessions = load_all_sessions
 
       if current_dir
         current_sessions = sessions.select { |s| s[:working_dir] == current_dir }
@@ -227,6 +238,36 @@ module Clacky
       limit ? sessions.first(limit) : sessions
     end
 
+    # Reuse a scan for a short window: the first paint fires several list
+    # requests at once and, without sharing, each one re-parses every session
+    # file and they queue up on the GVL. A snapshot older than the window is
+    # dropped before the next scan, so this does not grow into a long-lived cache.
+    private def load_all_sessions
+      if @recent_list && monotonic_now - @recent_list_at < LIST_REUSE_WINDOW
+        return @recent_list.dup
+      end
+
+      @list_mutex.synchronize do
+        now = monotonic_now
+        return @recent_list.dup if @recent_list && now - @recent_list_at < LIST_REUSE_WINDOW
+
+        # Release the old snapshot before scanning so its parsed messages can be
+        # collected instead of being held alongside the new ones.
+        @recent_list = nil
+        @recent_list = Dir.glob(File.join(@sessions_dir, "*.json"))
+                          .filter_map { |filepath| load_session_file(filepath) }
+                          .sort_by { |s| [s[:updated_at] || s[:created_at] || "", s[:session_id].to_s] }
+                          .reverse
+        @recent_list_at = now
+        # Callers get their own array so a sort!/push cannot reorder the shared one.
+        @recent_list.dup
+      end
+    end
+
+    private def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
     # Full-text grep over session JSON + chunk MD files.
     # Case-sensitive: BSD grep -i is ~30x slower; Chinese has no case.
     # Returns Hash<short_id String => snippet String> (snippet around the first match).
@@ -415,13 +456,19 @@ module Clacky
     # Soft-delete: stamp deleted_at, move JSON + chunks to sessions-trash/.
     def soft_delete(session_id)
       require_relative "tools/trash_manager"
-      Clacky::Tools::TrashManager.soft_delete_session(session_id, sessions_dir: @sessions_dir)
+      deleted = Clacky::Tools::TrashManager.soft_delete_session(session_id, sessions_dir: @sessions_dir)
+      # The file is moved outside this object's save path, so drop the shared
+      # list explicitly instead of waiting for the reuse window to lapse.
+      @recent_list_at = 0.0 if deleted
+      deleted
     end
 
     # Restore a soft-deleted session back to the active sessions directory.
     def restore_session(session_id)
       require_relative "tools/trash_manager"
-      Clacky::Tools::TrashManager.restore_session(session_id, sessions_dir: @sessions_dir)
+      restored = Clacky::Tools::TrashManager.restore_session(session_id, sessions_dir: @sessions_dir)
+      @recent_list_at = 0.0 if restored
+      restored
     end
 
     # List all soft-deleted sessions (newest-first).

data/lib/clacky/utils/mac_app_detector.rb

@@ -59,16 +59,17 @@ module Clacky
         return nil unless Utils::EnvironmentDetector.os_type == :macos
 
         ext = File.extname(path).downcase.sub(/\A\./, "")
-        return nil if ext.empty?
-
+        # LaunchServices answers for any URL, extension or not, so a Dockerfile
+        # resolves like any other file. Only extension answers are cacheable.
         @default_app_cache ||= {}
-        return @default_app_cache[ext] if @default_app_cache.key?(ext)
+        return @default_app_cache[ext] if !ext.empty? && @default_app_cache.key?(ext)
 
         bundle = default_app_bundle(path)
-        @default_app_cache[ext] =
-          if bundle && File.directory?(bundle)
-            { "name" => File.basename(bundle, ".app"), "path" => bundle }
-          end
+        app = if bundle && File.directory?(bundle)
+          { "name" => File.basename(bundle, ".app"), "path" => bundle }
+        end
+        @default_app_cache[ext] = app unless ext.empty?
+        app
       end
 
       # Query LaunchServices for the default handler of `path` via NSWorkspace.

data/lib/clacky/utils/model_pricing.rb

@@ -389,6 +389,38 @@ module Clacky
         }
       },
 
+      # Kimi K3.1 Pro (1M context, native vision, tool calling).
+      # Source: https://platform.kimi.ai (USD / 1M tokens)
+      "kimi-k3.1-pro" => {
+        input: {
+          default: 2.00,                   # $2.00/MTok cache miss
+          over_200k: 2.00
+        },
+        output: {
+          default: 10.00,                  # $10.00/MTok
+          over_200k: 10.00
+        },
+        cache: {
+          write: 2.00,                     # bill at miss rate (= 5m write price)
+          read: 0.20                       # $0.20/MTok cache hit
+        }
+      },
+
+      "kimi-k3.1-pro-highspeed" => {
+        input: {
+          default: 4.00,                   # $4.00/MTok cache miss
+          over_200k: 4.00
+        },
+        output: {
+          default: 20.00,                  # $20.00/MTok
+          over_200k: 20.00
+        },
+        cache: {
+          write: 4.00,                     # bill at miss rate (= 5m write price)
+          read: 0.20                       # $0.20/MTok cache hit
+        }
+      },
+
       # Kimi K3 flagship model (1M context, native vision, tool calling).
       # Source: https://platform.moonshot.ai (USD / 1M tokens)
       "kimi-k3" => {
@@ -597,6 +629,27 @@ module Clacky
         output: { default: 2.22, over_200k: 2.22 },
         cache:  { write: 0.45, read: 0.09 }
       },
+      "doubao-seed-2.1-lite" => {
+        input:  { default: 0.12, over_200k: 0.12 },
+        output: { default: 0.40, over_200k: 0.40 },
+        cache:  { write: 0.12, read: 0.03 }
+      },
+      # Ark's peak window (Mon-Fri 09-12/14-18 Beijing) equals DeepSeek's, so
+      # the economy tier reuses the deepseek peak/off-peak resolution. Cache
+      # reads keep three decimals: rounding up to the cent would double them.
+      "deepseek-v4.1-flash-economy" => {
+        deepseek: true,
+        peak: {
+          input:  { default: 0.24, over_200k: 0.24 },
+          output: { default: 0.95, over_200k: 0.95 },
+          cache:  { write: 0.24, read: 0.005 }
+        },
+        off_peak: {
+          input:  { default: 0.12, over_200k: 0.12 },
+          output: { default: 0.48, over_200k: 0.48 },
+          cache:  { write: 0.12, read: 0.003 }
+        }
+      },
       "doubao-seed-2.0-lite" => {
         input:  { default: 0.14, over_200k: 0.27 },
         output: { default: 0.80, over_200k: 1.60 },
@@ -1214,7 +1267,7 @@ module Clacky
     # served through a third party.
     # The gateway mirrors this list - see seriesDiscount in llm_proxy.
     DISCOUNT_RULES = [
-      { match: /\Aabs-claude-/,      rate: 0.6,  reason: "channel" }, # Claude via ciyuan cc-max - 40% off
+      { match: /\Aabs-claude-/,      rate: 0.45, reason: "channel" }, # Claude via ciyuan cc-max - 55% off
       { match: /\Aoc-glm-/,          rate: 0.95, reason: "channel" }, # GLM via ciyuan glm - 5% off
       { match: /\Aoc-kimi-/,         rate: 0.9,  reason: "channel" }, # Kimi K3 via ciyuan - 10% off
       { match: /\Aoc-grok-/,         rate: 0.3,  reason: "channel" }, # Grok 4.7 via ciyuan grok - 70% off
@@ -1429,6 +1482,11 @@ module Clacky
           "claude-3-5-haiku-20241022"
         when /deepseek-v4-pro/i, /deepseek.*v4.*pro/i
           "deepseek-v4-pro"
+        # V4.1 Flash — canonical generation id; natively multimodal. Must be
+        # matched BEFORE the v4-flash rules below, whose `.*v4.*flash` tails
+        # would otherwise catch "v4.1-flash".
+        when /deepseek-v4[.-]1-flash/i
+          "deepseek-flash"
         # Vision variant must be matched BEFORE the v4-flash rule below —
         # "deepseek-v4-flash-vision-exp" would otherwise be substring-matched
         # to v4-flash and billed at the wrong model's rate.
@@ -1436,7 +1494,7 @@ module Clacky
           "deepseek-v4-flash-vision-exp"
         when /deepseek-v4-flash/i, /deepseek.*v4.*flash/i
           "deepseek-v4-flash"
-        # V4.1 Flash — new canonical id; native multimodal.
+        # Bare upstream id for V4.1 Flash.
         when /deepseek-flash/i
           "deepseek-flash"
         # Legacy aliases: deepseek-chat and deepseek-reasoner are being

data/lib/clacky/utils/windows_app_detector.rb

@@ -219,7 +219,9 @@ module Clacky
         return nil unless wsl?
 
         ext = normalize_ext(File.extname(path))
-        return nil if ext.empty?
+        # Windows has no extension to look up for a Dockerfile or Makefile;
+        # ask what handles plain text instead of reporting nothing.
+        ext = "txt" if ext.empty?
 
         data = detect_for_ext(ext)
         data ? data["default"] : nil

data/lib/clacky/version.rb

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