openclacky 1.5.12 → 1.5.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 858730306a6e6647d79a5ebb35160c52fba7ed26c62ec97043373e7f052332e2
-  data.tar.gz: b412bc405daae81f1b6d71dd4dd2dffc197a00ac97540ecfd4916f7daf58843d
+  metadata.gz: 87ba4a4c52b1e52b0af0aad921bac4b8addd3d95955f44442894753ffd73ad14
+  data.tar.gz: 0a861cf43fcecc64275cb243029f7cc621ac32dfab949e0768aadfaf7e0f9490
 SHA512:
-  metadata.gz: 685d67556e68efd81a8bc446edd473a57939f0404b754e4432c7d29e073d2c47adc0c939fc5da3ea32144f3c6026aa17d73ff4766420399515089a3a8a4bc98d
-  data.tar.gz: dc85168d4b103185d20087635cfc5972c4e3e23b8dee95cb2ba28017d276dda425d8d92d23159dad463bd6cdcc29b8e02404d50dd4a79e5e6345193e8b4167c8
+  metadata.gz: 1b476b0c9ef80a39ac6830c35cac601abb5086d639d2806fc473af3a9074af25449f6f8befeea54bc07e38571e484f4012150d3a53adef674534f8b89ca8771e
+  data.tar.gz: 5ee52bb903109343a3a7adb9dc3681be836e22dd43f1b12021def3b32383c205b3750283b3af357f0e01b580ad1f5a8e2507c9f6133789b4813378e5a56120b3

data/CHANGELOG.md

@@ -4,6 +4,105 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.14] - 2026-09-10
+
+### Added
+- Add a click-driven live preview panel for workspace files and localhost dev servers
+- Open local files in the preview panel via file:// URLs and bare absolute paths
+- Add GPT-5.6 Sol/Terra/Luna and GPT-6 Astra models with Global CRIS pricing
+- Add the deepseek-flash model
+- Add an editable Chinese metadata form and field-level frontmatter update API for skills
+- Add a /think reasoning-effort switcher to the TUI
+- Render CSV/TSV files as read-only tables in the workspace
+- Add Parallel Free as the primary built-in web-search provider
+- Select text in a message and quote it into the composer (#526 - @kylezhang)
+- Syntax-highlight code in the file viewer
+- Send large STT audio as base64 JSON (#525 - @tomash)
+- Add a Files panel open-with menu, tree toggle, split preview, and in-menu download
+- Detect Windows apps for open-with in WSL
+- Skip registering the browser tool when it is disabled
+- Auto-snapshot the page after browser actions
+- Truncate long working directories in the session info bar
+- Highlight width-drag handles on hover
+
+### Improved
+- Switch the default model to Gemini 3.8 Flash
+- Use single-pane navigation on mobile (C-5779) (#539)
+- Polish the chat navigator layout and hover interactions (#527)
+- Improve message navigation in long conversations (#523)
+- Refine the billing tooltip UX (C-5778) (#537)
+- Let the git panel fill the aside height and free up diff width (#531)
+
+### Fixed
+- Restore the aside width after closing file previews (#545)
+- Replace undefined danger tokens with the error color variable (#542 - @sundevilyang)
+- Add hover and disabled feedback to danger and secondary buttons (#541, #540 - @sundevilyang)
+- Correct DeepSeek v4-pro and flash pricing
+- Collapse extension actions into a menu on narrow screens (C-5781) (#538)
+- Don't submit argumented commands on Enter
+- Scroll overflow menus and pin config action buttons
+- Sniff binary content before text preview (C-5690) (#535)
+- Require a slash prefix for channel help commands (C-5641) (#533)
+- Normalize the homepage URL scheme on read (C-5666) (#534)
+- Decode non-ASCII paths in git panel output (C-5777) (#530)
+- Refresh the file tree on working-dir switch and task completion
+- Harden extension developer guidance and manifest validation (#524)
+- Fix zip file encoding errors
+- Resolve file://~/ tilde paths from chat links
+- Align the open-button icon
+
+### More
+- Move the preview tab to the end of the left-nav order
+- Extract provider id constants to replace magic strings
+
+## [1.5.13] - 2026-09-03
+
+### Added
+- Add Gemini 3.8 Flash model and set it as the trial default
+- Add or-stt-gemini-3-8-flash speech-to-text model; default STT and video understanding to 3.8
+- Add OpenAI Responses API as a fourth API format (#490 - @kylezhang)
+- Add access-key API and config-reload API
+- Add Claude Fable 5.1, GLM-5.3-Flash and qwen3.8-max models with pricing
+- Default the Web UI to the OS/browser language on first visit
+- Make the workspace file tree resizable
+- Expose mounted drives in the directory picker
+- Personalize the new-session page title and empty-chat greeting with the AI's name
+- Localise built-in setup session titles
+
+### Improved
+- Replace native selects with shared CustomSelect dropdowns across settings
+- Overhaul the git & time-machine panel
+- Improve the directory picker (#521)
+
+### Fixed
+- Merge OpenClacky billing across all configured API keys
+- Preserve custom provider and API format when editing a model
+- Reclaim PTY file descriptors when a session shell dies
+- Wrap ANSI-coloured CJK text without IndexError
+- Prevent history edits while a session is running (#520)
+- Preserve attachment badges after compression (#516)
+- Flag hidden agents instead of dropping them
+- Install upgrades next to the running gem's base directory
+- Skip extension auto-sync for administrators (#515)
+- Support the mention menu with Windows IME (#513)
+- Validate extension version input (#514)
+- Keep mention chips anchored and on one line while typing
+- Fall back to uncolored markdown for CJK tables
+- Stabilise billing toolbar layout (#517)
+- Light the group unread dot for backend-created sessions (#518)
+- Translate maximum reasoning effort (#522)
+- Harden WSL Windows profile detection in the directory picker
+- Wrap download errors so the CDN fallback fires
+- Surface the git tab badge eagerly
+- Show the meeting panel only in general sessions
+- Whitelist the config top-level key in the extension verifier
+
+### More
+- Extract shared ModelPicker model dropdown component
+- Refine dropdown chevrons and submenu selection
+- Adjust sidebar panel order and labels
+- Update trial model copy to Gemini 3.7 Flash
+
 ## [1.5.12] - 2026-08-27
 
 ### Added

data/lib/clacky/access_key.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "securerandom"
+
+module Clacky
+  # Access key for server-mode authentication.
+  #
+  # Two sources, in priority order:
+  #   1. ~/.clacky/access_key — a file holding the raw key, writable from
+  #      outside the process (e.g. a sandbox host pushing a key into a
+  #      pre-started container). This is what makes rotation possible:
+  #      ENV is a boot-time snapshot the running process can never change.
+  #   2. CLACKY_ACCESS_KEY env var — the original bootstrap mechanism.
+  module AccessKey
+    ENV_VAR = "CLACKY_ACCESS_KEY"
+
+    def self.resolve
+      from_file || from_env
+    end
+
+    def self.from_file
+      return nil unless File.exist?(key_file)
+
+      key = File.read(key_file).strip
+      key.empty? ? nil : key
+    rescue StandardError
+      nil
+    end
+
+    def self.from_env
+      key = ENV.fetch(ENV_VAR, "").strip
+      key.empty? ? nil : key
+    end
+
+    def self.write(key)
+      key = key.to_s.strip
+      raise ArgumentError, "access key must not be blank" if key.empty?
+
+      FileUtils.mkdir_p(File.dirname(key_file))
+      File.write(key_file, "#{key}\n")
+      FileUtils.chmod(0o600, key_file)
+      key
+    end
+
+    def self.generate
+      SecureRandom.hex(32)
+    end
+
+    def self.configured?
+      !resolve.nil?
+    end
+
+    # Resolved lazily so specs that stub Dir.home in a before-hook still work.
+    def self.key_file
+      File.join(Dir.home, ".clacky", "access_key")
+    end
+  end
+end

data/lib/clacky/agent/chunk_index.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Byte ranges only: no message bodies, tool outputs or persistent sidecars.
+    module ChunkIndex
+      private def chunk_section_header(line, directory)
+        if (match = line.match(/\A## Assistant \[Compressed Summary — original conversation at: (.+)\]/))
+          { role: "assistant", nested_chunk: File.join(directory, match[1]) }
+        elsif (match = line.match(/\A## (User|Assistant)(?: \[Task ([1-9]\d*)\])?\z/))
+          { role: match[1].downcase, task_id: match[2]&.to_i }
+        elsif line.start_with?("### Tool Result:")
+          { role: "tool" }
+        end
+      end
+
+      private def chunk_file_version(path)
+        stat = File.stat(path)
+        [stat.size, stat.mtime.to_f, stat.ctime.to_f].join(":")
+      rescue Errno::ENOENT
+        "missing"
+      end
+
+      private def chunk_navigation_index(path)
+        version = chunk_file_version(path)
+        @chunk_index_mutex ||= Mutex.new
+        @chunk_index_mutex.synchronize do
+          @chunk_indexes ||= {}
+          cached = @chunk_indexes[path]
+          return cached if cached && cached[:version] == version
+
+          index = version == "missing" ? { rounds: [], nested: [], section_count: 0 } : scan_chunk_index(path)
+          raise ArgumentError, "History changed while indexing" unless chunk_file_version(path) == version
+
+          @chunk_indexes[path] = index.merge(version: version)
+        end
+      end
+
+      private def scan_chunk_index(path)
+        rounds = []
+        nested = []
+        section_count = 0
+        user_start = nil
+        archived_at = nil
+        front_matter = false
+        directory = File.dirname(path)
+        position = 0
+        File.open(path, "rb") do |file|
+          while (line = file.gets)
+            start = position
+            position += line.bytesize
+            text = line.force_encoding(Encoding::UTF_8).scrub.chomp
+            if start.zero? && text == "---"
+              front_matter = true
+            elsif front_matter
+              front_matter = false if text == "---"
+              archived_at = (Time.parse(text.split(":", 2).last.strip) rescue nil) if text.start_with?("archived_at:")
+            end
+            header = chunk_section_header(text, directory)
+            if header
+              section_count += 1
+              nested << header[:nested_chunk] if header[:nested_chunk]
+              user_start = header[:role] == "user" ? start : nil
+            elsif user_start && !text.strip.empty?
+              # Match replay's empty/metadata-only user handling without
+              # retaining the rest of the user message or any assistant text.
+              visible, events = extract_ext_events_from_text(text)
+              visible, files = extract_display_files_from_text(visible)
+              next if visible.empty? && events.empty? && files.empty?
+
+              rounds.last[:length] = user_start - rounds.last[:start] if rounds.any?
+              rounds << { start: user_start }
+              user_start = nil
+            end
+          end
+          rounds.last[:length] = position - rounds.last[:start] if rounds.any?
+        end
+        { rounds: rounds, nested: nested, section_count: section_count,
+          base_time: (archived_at || File.mtime(path)).to_f }
+      end
+    end
+  end
+end

data/lib/clacky/agent/history_navigation.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    # Read-only navigation: locations at startup, bounded previews on demand.
+    module HistoryNavigation
+      NAVIGATION_PREVIEW_LENGTH = 400
+      NAVIGATION_PREVIEW_BATCH_LIMIT = 30
+
+      def history_navigation
+        sources = navigation_sources
+        manifest = sources.map do |source|
+          entry = { key: source[:key], version: source[:version], count: navigation_source_count(source),
+                    volatile: !!source[:rounds] || source[:continuation].to_a.any? }
+          entry[:identities] = source[:rounds].map { |round| round[:user_msg].values_at(:created_at, :task_id) } if source[:rounds]
+          entry
+        end
+        { sources: manifest, total: manifest.sum { |source| source[:count] } }
+      end
+
+      def history_navigation_preview(id:)
+        history_navigation_previews(ids: [id]).fetch(0)
+      end
+
+      def history_navigation_previews(ids:)
+        ids = Array(ids)
+        if ids.length > NAVIGATION_PREVIEW_BATCH_LIMIT
+          raise ArgumentError, "Too many history locations"
+        end
+
+        sources = navigation_sources
+        ids.map do |id|
+          source_index, offset = navigation_position(sources, id)
+          unless offset && offset < navigation_source_count(sources[source_index])
+            raise ArgumentError, "History location is no longer available"
+          end
+          navigation_entry(navigation_source_rounds(sources, source_index, offset: offset, limit: 1).fetch(0))
+        end
+      end
+
+      def replay_history_window(ui, limit: 30, around: nil, before_id: nil, after_id: nil)
+        sources = navigation_sources
+        anchor = around || before_id || after_id
+        source_index, offset = anchor ? navigation_position(sources, anchor) : [sources.length - 1, nil]
+        count = navigation_source_count(sources[source_index])
+        offset ||= count
+        raise ArgumentError, "History location is no longer available" if anchor && offset >= count
+
+        # Around starts at the requested round; before/after are exclusive.
+        forward = !!(around || after_id)
+        offset += 1 if after_id
+        page = []
+        index = source_index
+        while index.between?(0, sources.length - 1) && page.length < limit
+          count = navigation_source_count(sources[index])
+          if forward
+            first = index == source_index ? offset : 0
+            page.concat(navigation_source_rounds(sources, index, offset: first, limit: limit - page.length))
+            index += 1
+          else
+            last = index == source_index ? offset : count
+            first = [last - (limit - page.length), 0].max
+            page = navigation_source_rounds(sources, index, offset: first, limit: last - first) + page
+            index -= 1
+          end
+        end
+
+        if page.empty? && !anchor
+          @history.to_a.each do |message|
+            next if message[:role].to_s == "system" || message[:system_injected]
+            _replay_single_message(message, ui)
+          end
+        else
+          replay_rounds(ui, page)
+        end
+        first = page.first&.dig(:navigation_id)
+        last = page.last&.dig(:navigation_id)
+        first_pos = first && navigation_position(sources, first)
+        last_pos = last && navigation_position(sources, last)
+        has_before = first_pos && (first_pos[1].positive? || first_pos[0].positive?)
+        has_after = last_pos && (last_pos[1] < navigation_source_count(sources[last_pos[0]]) - 1 ||
+          ((last_pos[0] + 1)...sources.length).any? { |i| navigation_source_count(sources[i]).positive? })
+        {
+          has_more: !!has_before, has_after: !!has_after,
+          before_cursor: first, after_cursor: last,
+          round_ids: page.map { |round| round[:navigation_id] }
+        }
+      end
+
+      private def real_history_user?(msg)
+        return false unless msg[:role].to_s == "user" && !msg[:system_injected]
+
+        content = msg[:content]
+        if content.is_a?(String)
+          !content.start_with?("[SYSTEM]")
+        elsif content.is_a?(Array)
+          content.any? { |block| block.is_a?(Hash) && %w[text image image_url].include?((block[:type] || block["type"]).to_s) }
+        else
+          false
+        end
+      end
+
+      private def navigation_sources
+        messages = @history.to_a
+        rounds = []
+        leading = []
+        chunks = []
+        messages.each do |msg|
+          if real_history_user?(msg)
+            rounds << { user_msg: msg, events: [], editable: true }
+          elsif msg[:compressed_summary]
+            paths = if msg[:chunk_path].to_s.empty?
+              session_manager.chunks_for_current(@session_id, @created_at).map { |chunk| chunk[:path] }
+            else
+              sibling_chunks_of(msg[:chunk_path])
+            end
+            chunks.concat(paths)
+          elsif rounds.empty?
+            leading << msg unless msg[:role].to_s == "system" || msg[:system_injected]
+          else
+            rounds.last[:events] << msg
+          end
+        end
+        sources = []
+        visited = Set.new
+        top_level = chunks.map { |path| File.basename(path) }.to_set
+        append_source = lambda do |path|
+          path = File.join(Clacky::SessionManager::SESSIONS_DIR, File.basename(path)) unless File.exist?(path)
+          path = File.expand_path(path)
+          next unless visited.add?(path)
+
+          index = chunk_navigation_index(path)
+          # Legacy nested references precede this source's own rounds. Sibling
+          # chunks already enumerated above must not be counted twice.
+          index[:nested].reverse_each do |nested|
+            append_source.call(nested) unless top_level.include?(File.basename(nested))
+          end
+          sources << { key: File.basename(path), path: path, version: index[:version], index: index }
+        end
+        chunks.uniq.each { |path| append_source.call(path) }
+        @chunk_index_mutex&.synchronize { @chunk_indexes&.delete_if { |path, _| !visited.include?(path) } }
+        last_archive = sources.reverse_each.find { |source| navigation_source_count(source).positive? }
+        last_archive[:continuation] = leading if last_archive
+        version = rounds.map { |round| round[:user_msg].values_at(:created_at, :task_id) }.hash.to_s
+        sources << { key: "live", rounds: rounds, version: version }
+        sources
+      end
+
+      private def navigation_source_count(source)
+        source[:rounds] ? source[:rounds].length : source[:index][:rounds].length
+      end
+
+      private def navigation_id(source, offset)
+        identity = source[:rounds] && offset && source[:rounds][offset]&.dig(:user_msg)&.values_at(:created_at, :task_id)
+        JSON.generate([source[:key], offset, source[:version], identity])
+      end
+
+      private def navigation_position(sources, id)
+        key, offset, version, identity = JSON.parse(id)
+        index = sources.index { |source| source[:key] == key }
+        if index && key == "live" && version != sources[index][:version] && identity.is_a?(Array) && identity.any?
+          matches = sources[index][:rounds].each_index.select do |i|
+            sources[index][:rounds][i][:user_msg].values_at(:created_at, :task_id) == identity
+          end
+          if matches.one?
+            offset = matches.first
+            version = sources[index][:version]
+          end
+        end
+        unless index && sources[index][:version] == version && (offset.nil? || (offset.is_a?(Integer) && offset >= 0))
+          raise ArgumentError, "History location is no longer available"
+        end
+        [index, offset]
+      rescue JSON::ParserError, TypeError
+        raise ArgumentError, "Invalid history location"
+      end
+
+      private def navigation_source_rounds(sources, index, offset: 0, limit: nil)
+        source = sources.fetch(index)
+        count = navigation_source_count(source)
+        length = [limit || count, count - offset].min
+        return [] unless length.positive?
+
+        siblings = sources.filter_map { |entry| entry[:key] if entry[:path] && entry != source }.to_set
+        rounds = if source[:rounds]
+          source[:rounds].slice(offset, length)
+        else
+          ranges = source[:index][:rounds]
+          first = ranges[offset]
+          last = ranges[offset + length - 1]
+          range = { start: first[:start], length: last[:start] + last[:length] - first[:start] }
+          result = parse_chunk_md_to_rounds(source[:path], excluded_paths: siblings, byte_range: range,
+            index: source[:index], round_offset: offset)
+          unless chunk_file_version(source[:path]) == source[:version] && result.length == length
+            raise ArgumentError, "History changed while reading"
+          end
+          result
+        end
+        if rounds.any? && offset + length == count && source[:continuation]
+          rounds.last[:events].concat(source[:continuation])
+        end
+        rounds.each { |round| round[:events].reject! { |event| event[:compressed_summary] } }
+        rounds.each_with_index do |round, position|
+          round[:navigation_id] = navigation_id(source, offset + position)
+        end
+        rounds
+      end
+
+      private def navigation_entry(round)
+        msg = round[:user_msg]
+        user = navigation_preview(msg[:display_text] || extract_text_from_content(msg[:content]))
+        if user.empty?
+          names = Array(msg[:display_files]).map { |file| file[:name] || file["name"] }
+          Array(msg[:content]).each do |block|
+            next unless block.is_a?(Hash) && %w[image image_url].include?((block[:type] || block["type"]).to_s)
+            names << (block[:image_name] || block["image_name"] || "image")
+          end
+          user = navigation_preview(names.compact.join(", "))
+        end
+        # A final reply is the last main-agent response, with no pending tool
+        # work. Earlier narration, reasoning and nested subagent transcripts
+        # must never be substituted for a missing final response.
+        last = round[:events].reverse.find do |event|
+          !event[:system_injected] && !event[:compressed_summary] &&
+            %w[assistant tool].include?(event[:role].to_s)
+        end
+        final = last && last[:role].to_s == "assistant" && !last[:interim] && Array(last[:tool_calls]).empty?
+        answer = final ? navigation_preview(extract_text_from_content(last[:content])) : ""
+        { id: round[:navigation_id], created_at: msg[:created_at], archived: round[:editable] == false,
+          user: user, assistant: answer }
+      end
+
+      private def navigation_preview(text)
+        text.to_s.gsub(/<think>.*?(?:<\/think>|\z)/m, "")
+          .strip[0, NAVIGATION_PREVIEW_LENGTH]
+      end
+    end
+  end
+end

data/lib/clacky/agent/message_compressor_helper.rb

@@ -624,10 +624,12 @@ module Clacky
 
           case role
           when "user"
+            display_files = display_files_for_archive(msg)
             lines << (msg[:task_id] ? "## User [Task #{msg[:task_id]}]" : "## User")
             lines << ""
-            lines << format_message_content(content)
+            lines << format_archived_user_content(content, display_files)
             lines << ""
+            append_display_files_line(lines, display_files)
             append_ext_events_line(lines, msg)
           when "assistant"
             # If this message is itself a compressed summary, annotate the header
@@ -676,6 +678,55 @@ module Clacky
         lines
       end
 
+      # Serialize only the lightweight UI metadata needed to reconstruct file
+      # badges after compression. File paths, previews, sizes, MIME types, and
+      # contents deliberately stay out of the chunk archive.
+      def display_files_for_archive(msg)
+        files = Array(msg[:display_files]).dup
+        Array(msg[:content]).each do |block|
+          next unless block.is_a?(Hash)
+          next unless %w[image image_url].include?((block[:type] || block["type"]).to_s)
+
+          name = block[:image_name] || block["image_name"]
+          if name.nil? || name.to_s.strip.empty?
+            path = block[:image_path] || block["image_path"]
+            name = File.basename(path.to_s).sub(/\A[0-9a-f]{16}_/, "") unless path.to_s.empty?
+          end
+          name = "image" if name.nil? || name.to_s.strip.empty?
+          files << { name: name, type: "image" }
+        end
+
+        files.filter_map do |file|
+          next unless file.is_a?(Hash)
+
+          name = file[:name] || file["name"]
+          next if name.nil? || name.to_s.strip.empty?
+
+          type = file[:type] || file["type"] || "file"
+          type = "file" if type.to_s.strip.empty?
+          { name: name.to_s, type: type.to_s }
+        end.uniq { |file| [file[:name], file[:type]] }
+      end
+
+      # Once an image has a badge in the archive, omit the generic [image_url]
+      # placeholder from the visible replay text. Text blocks remain unchanged.
+      def format_archived_user_content(content, display_files)
+        return format_message_content(content) unless content.is_a?(Array)
+        return format_message_content(content) unless display_files.any? { |file| file[:type] == "image" }
+
+        visible_blocks = content.reject do |block|
+          block.is_a?(Hash) && %w[image image_url].include?((block[:type] || block["type"]).to_s)
+        end
+        format_message_content(visible_blocks)
+      end
+
+      def append_display_files_line(lines, files)
+        return if files.empty?
+
+        lines << "_Display files: #{files.to_json}_"
+        lines << ""
+      end
+
       # Serialize persisted extension events into the chunk MD so they survive
       # compression and can be replayed in place. Mirrors the "_Tool calls:"
       # convention; parse_chunk_md_to_rounds reads it back.