openclacky 0.9.35 → 0.9.36

data/lib/clacky/server/http_server.rb

@@ -606,6 +606,52 @@ module Clacky
 
       # ── Brand API ─────────────────────────────────────────────────────────────
 
+      # Process-wide mutex guarding heartbeat trigger state.
+      # Used by #trigger_async_heartbeat! to ensure only one heartbeat Thread is
+      # in flight at a time, no matter how many concurrent /api/brand/status
+      # requests arrive from the Web UI poller.
+      BRAND_HEARTBEAT_MUTEX   = Mutex.new
+      # Tracks whether a heartbeat Thread is currently running.
+      @@brand_heartbeat_inflight = false
+
+      # Fire a heartbeat in a background Thread without blocking the caller.
+      #
+      # Contract:
+      #   * Only one heartbeat Thread may be running at any moment across the
+      #     whole process. If one is already in flight, this call is a no-op.
+      #   * The caller never waits: it returns immediately after (at most)
+      #     spawning the Thread.
+      #   * The Thread rescues everything so a network failure cannot kill the
+      #     server or leak an exception through the web stack.
+      def trigger_async_heartbeat!
+        BRAND_HEARTBEAT_MUTEX.synchronize do
+          if @@brand_heartbeat_inflight
+            Clacky::Logger.debug("[Brand] heartbeat already in flight, skipping")
+            return
+          end
+          @@brand_heartbeat_inflight = true
+        end
+
+        Thread.new do
+          Clacky::Logger.info("[Brand] async heartbeat starting...")
+          begin
+            brand  = Clacky::BrandConfig.load
+            result = brand.heartbeat!
+            if result[:success]
+              Clacky::Logger.info("[Brand] async heartbeat OK")
+            else
+              Clacky::Logger.warn("[Brand] async heartbeat failed — #{result[:message]}")
+            end
+          rescue StandardError => e
+            Clacky::Logger.warn("[Brand] async heartbeat raised: #{e.class}: #{e.message}")
+          ensure
+            BRAND_HEARTBEAT_MUTEX.synchronize do
+              @@brand_heartbeat_inflight = false
+            end
+          end
+        end
+      end
+
       # GET /api/brand/status
       # Returns whether brand activation is needed.
       # Mirrors the onboard/status pattern so the frontend can gate on it.
@@ -634,17 +680,15 @@ module Clacky
           return
         end
 
-        # Send heartbeat if interval has elapsed (once per day)
+        # Send heartbeat asynchronously if interval has elapsed (once per day).
+        #
+        # We must NOT block this HTTP response on the heartbeat call: a slow or
+        # unreachable license server would otherwise stall the Web UI's first
+        # paint for up to ~92s (2 hosts × 2 attempts × 23s timeout). The fresh
+        # expires_at / last_heartbeat will be picked up on the next /api/brand/status
+        # poll, which is sufficient for a once-per-day check.
         if brand.heartbeat_due?
-          Clacky::Logger.info("[Brand] api_brand_status: heartbeat due, sending...")
-          result = brand.heartbeat!
-          if result[:success]
-            Clacky::Logger.info("[Brand] api_brand_status: heartbeat OK")
-          else
-            Clacky::Logger.warn("[Brand] api_brand_status: heartbeat failed — #{result[:message]}")
-          end
-          # Reload after heartbeat to pick up updated expires_at / last_heartbeat
-          brand = Clacky::BrandConfig.load
+          trigger_async_heartbeat!
         else
           Clacky::Logger.debug("[Brand] api_brand_status: heartbeat not due yet")
         end
@@ -1828,6 +1872,7 @@ module Clacky
       def api_get_config(res)
         models = @agent_config.models.map.with_index do |m, i|
           {
+            id:               m["id"],   # Stable runtime id — use this for switching
             index:            i,
             model:            m["model"],
             base_url:         m["base_url"],
@@ -1838,12 +1883,19 @@ module Clacky
         end
         # Filter out auto-injected models (like lite) from UI display
         models.reject! { |m| @agent_config.models[m[:index]]["auto_injected"] }
-        json_response(res, 200, { models: models, current_index: @agent_config.current_model_index })
+        json_response(res, 200, {
+          models: models,
+          current_index: @agent_config.current_model_index,
+          current_id: @agent_config.current_model&.dig("id")
+        })
       end
 
       # POST /api/config — save updated model list
-      # Body: { models: [ { index, model, base_url, api_key, anthropic_format, type } ] }
-      # api_key may be masked ("sk-ab12****...5678") — keep existing key in that case
+      # Body: { models: [ { id?, index, model, base_url, api_key, anthropic_format, type } ] }
+      # - id may be present for existing models (preserved) or absent for newly added
+      #   models (a new id is generated). Ids are runtime-only and stripped before
+      #   writing to config.yml (see AgentConfig#to_yaml).
+      # - api_key may be masked ("sk-ab12****...5678") — keep existing key in that case
       def api_save_config(req, res)
         body = parse_json_body(req)
         return json_response(res, 400, { error: "Invalid JSON" }) unless body
@@ -1851,8 +1903,18 @@ module Clacky
         incoming = body["models"]
         return json_response(res, 400, { error: "models array required" }) unless incoming.is_a?(Array)
 
-        incoming.each_with_index do |m, i|
-          existing = @agent_config.models[i]
+        # Build a quick id→existing-model lookup. Ids are the single source
+        # of identity for models across save/reload cycles — no index-based
+        # fallback (ids are stable; indexes are not). Live sessions' stored
+        # @current_model_id stays valid as long as the id is still present
+        # in the list after save.
+        existing_by_id = {}
+        @agent_config.models.each { |m| existing_by_id[m["id"]] = m if m["id"] }
+
+        new_models = incoming.map do |m|
+          # Lookup by id only. No id means a brand-new model — we mint one.
+          existing = m["id"] && existing_by_id[m["id"]]
+
           # Resolve api_key: if masked placeholder, keep the stored key
           api_key = if m["api_key"].to_s.include?("****")
                       existing&.dig("api_key")
@@ -1860,26 +1922,26 @@ module Clacky
                       m["api_key"]
                     end
 
-          if existing
-            existing["model"]            = m["model"]            if m.key?("model")
-            existing["base_url"]         = m["base_url"]         if m.key?("base_url")
-            existing["api_key"]          = api_key               if api_key
-            existing["anthropic_format"] = m["anthropic_format"] if m.key?("anthropic_format")
-            existing["type"]             = m["type"]             if m.key?("type")
-          else
-            @agent_config.add_model(
-              model:            m["model"].to_s,
-              api_key:          api_key.to_s,
-              base_url:         m["base_url"].to_s,
-              anthropic_format: m["anthropic_format"] || false,
-              type:             m["type"]
-            )
-          end
+          {
+            "id"               => (existing && existing["id"]) || SecureRandom.uuid,
+            "model"            => m["model"].to_s,
+            "base_url"         => m["base_url"].to_s,
+            "api_key"          => api_key.to_s,
+            "anthropic_format" => m["anthropic_format"] || false,
+            "type"             => m["type"]
+          }.tap { |h| h.delete("type") if h["type"].nil? || h["type"].to_s.empty? }
         end
 
-        # Remove models that are no longer present (trim to incoming length)
-        while @agent_config.models.length > incoming.length
-          @agent_config.models.pop
+        # Replace @models in place — do NOT reassign the array, because every
+        # live session holds a reference to the same array (Plan B shared
+        # models). `replace` mutates in place so all sessions see the new list.
+        @agent_config.models.replace(new_models)
+
+        # Re-anchor current_model_index to the model still holding type: default
+        if (new_default_idx = new_models.find_index { |m| m["type"] == "default" })
+          @agent_config.current_model_index = new_default_idx
+        elsif @agent_config.current_model_index >= new_models.length
+          @agent_config.current_model_index = [new_models.length - 1, 0].max
         end
 
         @agent_config.save
@@ -2004,36 +2066,38 @@ module Clacky
 
       def api_switch_session_model(session_id, req, res)
         body = parse_json_body(req)
-        new_model_name = body["model"].to_s.strip
+        model_id = body["model_id"].to_s.strip
 
-        return json_response(res, 400, { error: "model is required" }) if new_model_name.empty?
+        return json_response(res, 400, { error: "model_id is required" }) if model_id.empty?
         return json_response(res, 404, { error: "Session not found" }) unless @registry.ensure(session_id)
 
         agent = nil
         @registry.with_session(session_id) { |s| agent = s[:agent] }
-        
-        # Find the model configuration index by model name (use global config)
-        model_index = @agent_config.models.find_index { |m| m["model"] == new_model_name }
-        
-        if model_index.nil?
-          return json_response(res, 400, { error: "Model '#{new_model_name}' not found in configuration" })
+
+        # With Plan B (shared @models reference), every session's AgentConfig
+        # points at the same @models array as the global @agent_config. So
+        # resolving the model by stable id here and in agent.switch_model_by_id
+        # will always agree — no more index divergence after add/delete.
+        target_model = @agent_config.models.find { |m| m["id"] == model_id }
+        if target_model.nil?
+          return json_response(res, 400, { error: "Model not found in configuration" })
         end
-        
-        # Switch to the model by index (unified interface with CLI)
-        # This handles: config.switch_model + client rebuild + message_compressor rebuild
-        success = agent.switch_model(model_index)
-        
+
+        # Switch to the model by id (unified interface with CLI)
+        # Handles: config.switch_model_by_id + client rebuild + message_compressor rebuild
+        success = agent.switch_model_by_id(model_id)
+
         unless success
           return json_response(res, 500, { error: "Failed to switch model" })
         end
-        
+
         # Persist the change (saves to session file, NOT global config.yml)
         @session_manager.save(agent.to_session_data)
-        
+
         # Broadcast update to all clients
         broadcast_session_update(session_id)
-        
-        json_response(res, 200, { ok: true, model: new_model_name })
+
+        json_response(res, 200, { ok: true, model_id: model_id, model: target_model["model"] })
       rescue => e
         json_response(res, 500, { error: e.message })
       end
@@ -2071,16 +2135,34 @@ module Clacky
       end
 
       def api_delete_session(session_id, res)
-        if @registry.delete(session_id)
-          # Also remove the persisted session file from disk
-          @session_manager.delete(session_id)
-          # Notify connected clients the session is gone
-          broadcast(session_id, { type: "session_deleted", session_id: session_id })
-          unsubscribe_all(session_id)
-          json_response(res, 200, { ok: true })
-        else
-          json_response(res, 404, { error: "Session not found" })
+        # A session exists if it's either in the runtime registry OR on disk.
+        # Old sessions that were never restored into memory this server run
+        # (e.g. shown via "load more" in the WebUI list) are disk-only — we
+        # must still be able to delete them. Previously this endpoint only
+        # consulted @registry and returned 404 for disk-only sessions,
+        # causing the "can't delete old sessions" bug.
+        in_registry = @registry.exist?(session_id)
+        on_disk     = !@session_manager.load(session_id).nil?
+
+        unless in_registry || on_disk
+          return json_response(res, 404, { error: "Session not found" })
         end
+
+        # Registry delete is best-effort — only meaningful when the session
+        # is actually live (cancels idle timer, interrupts the agent thread).
+        # For disk-only sessions this is a no-op and returns false, which is
+        # fine and no longer blocks the disk cleanup below.
+        @registry.delete(session_id) if in_registry
+
+        # Always physically remove the persisted session file (+ chunks).
+        @session_manager.delete(session_id) if on_disk
+
+        # Notify any still-connected clients (mainly matters when the
+        # session was live, but harmless otherwise).
+        broadcast(session_id, { type: "session_deleted", session_id: session_id })
+        unsubscribe_all(session_id)
+
+        json_response(res, 200, { ok: true })
       end
 
       # Export a session bundle as a .zip download containing:

data/lib/clacky/tools/terminal.rb

@@ -274,7 +274,7 @@ module Clacky
         raw = read_log_slice(session.log_file, start_offset, new_offset)
         cleaned = OutputCleaner.clean(raw)
         cleaned = cleaned.sub(session.marker_regex, "").rstrip if session.marker_regex
-        cleaned = strip_command_echo(cleaned)
+        cleaned = strip_command_echo(cleaned, marker_token: session.marker_token)
         truncated = false
         if cleaned.bytesize > MAX_LLM_OUTPUT_CHARS
           cleaned = cleaned.byteslice(0, MAX_LLM_OUTPUT_CHARS) + "\n...[output truncated]"
@@ -336,23 +336,97 @@ module Clacky
       # The shell may echo the wrapper line we injected (`{ USER_CMD; }; ...;
       # printf "__CLACKY_DONE_..."`) before running it. When stty -echo is
       # honoured (bash/fresh pty) this is a no-op; when it isn't (zsh ZLE
-      # sometimes re-enables echo on reuse) we strip the wrapper echo.
+      # sometimes re-enables echo on reuse, or the user sent input to a
+      # running session) we strip the wrapper echo wherever it appears.
       #
-      # Note: when the PTY is in cooked mode and echoes the wrapper, the
-      # terminal *interprets* the backslash-n escape pairs inside the
-      # double-quoted printf format, so the wrapper echo spans multiple
-      # real \n lines — not just two. We match lazily up to the closing
-      # `"$__clacky_ec"` quote so we catch the entire echoed wrapper.
-      private def strip_command_echo(text)
+      # Observed variants of the echoed wrapper:
+      #
+      #   1) Multi-line, starting the buffer (PTY in cooked mode, expanded
+      #      \n escapes inside printf's double-quoted format string):
+      #        { USER_CMD
+      #        }; __clacky_ec=$?; printf "
+      #        __CLACKY_DONE_<token>_%s__
+      #        " "$__clacky_ec"
+      #
+      #   2) Single-line / partially-truncated (PTY width wrap or partial
+      #      char drop ate the leading `{` or first chars of the command):
+      #        ails runner foo.rb ... }; __clacky_ec=$?; printf " __CLACKY_DONE_<token>_%s__ " "$__clacky_ec"
+      #
+      #   3) Embedded mid-stream when re-echoed (e.g. after session re-use
+      #      or after a user input: call landed in a shell that re-enabled
+      #      echo). Same shape as (1) or (2) but not anchored to the start.
+      #
+      # We handle all three by running two passes:
+      #   * an anchored multi-line strip (keeps the legacy behaviour and is
+      #     cheapest when stty -echo silently failed);
+      #   * a token-aware global strip that removes any remaining echoed
+      #     wrapper fragment anywhere in the buffer. The token makes this
+      #     safe: the real completion marker was already removed via
+      #     session.marker_regex above, so any surviving occurrence of
+      #     __CLACKY_DONE_<token>_ is by definition an echoed wrapper.
+      private def strip_command_echo(text, marker_token: nil)
         return text if text.nil? || text.empty?
-        # Match the whole echoed wrapper, however many lines the terminal
-        # expanded its \n escapes into:
-        #   { USER_CMD
-        #   }; __clacky_ec=$?; printf "
-        #   __CLACKY_DONE_<token>_%s__
-        #   " "$__clacky_ec"
-        # Anchored at the start; non-greedy across newlines via /m.
+
+        # Pass 1: anchored strip — the full wrapper echoed at the start,
+        # possibly spanning multiple real newlines.
         text = text.sub(/\A\{.*?"\$__clacky_ec"\s*\n?/m, "")
+
+        # Pass 2: token-aware global strip — remove any leftover wrapper
+        # echo fragment, wherever it sits. Requires the session token so
+        # we never touch unrelated user output that happens to mention
+        # `__clacky_ec`.
+        if marker_token && !marker_token.empty?
+          token_re = Regexp.escape(marker_token)
+
+          # 2a. Multi-line shape: walk back from __CLACKY_DONE_<token> to
+          # the opening `{` of the wrapper (start of line or start of
+          # buffer) and forward to the closing `"$__clacky_ec"`.
+          text = text.gsub(
+            /(?:^|(?<=\n))\{[^\n]*\n(?:[^\n]*\n)*?[^\n]*__CLACKY_DONE_#{token_re}_[^\n]*\n[^\n]*"\$__clacky_ec"[^\n]*\n?/,
+            ""
+          )
+
+          # 2b. Single-line shape: everything collapsed onto one line.
+          # Strip from the wrapper's `}; __clacky_ec=$?` pivot (or the
+          # opening `{` if still present on that line) through the end of
+          # the printf invocation (`"$__clacky_ec"`).
+          text = text.gsub(
+            /[^\n]*\}; *__clacky_ec=\$\?; *printf[^\n]*__CLACKY_DONE_#{token_re}_[^\n]*"\$__clacky_ec"[^\n]*\n?/,
+            ""
+          )
+
+          # 2c. Last-resort: a bare marker-format fragment on its own,
+          # without the `}; printf ...` prefix (e.g. terminal wrapped the
+          # echo such that only the tail survived). Drop lines that
+          # contain the literal `__CLACKY_DONE_<token>_%s__` format —
+          # the real marker has `\d+` in place of `%s` so this only hits
+          # echoed wrappers.
+          text = text.gsub(/^.*__CLACKY_DONE_#{token_re}_%s__.*\n?/, "")
+        end
+
+        # Pass 3: token-INDEPENDENT fingerprint strip — PTY width-wrap
+        # can chop the `__CLACKY_DONE_<token>_%s__` format string out of
+        # printf entirely, leaving e.g. `}; __clacky_ec=$?; printf " " "$__clacky_ec"`.
+        # None of the token-aware patterns above catch that. The pair
+        # `}; __clacky_ec=$?` (opening pivot) and `"$__clacky_ec"` (printf
+        # tail) are our wrapper's unique fingerprints — `__clacky_ec` is a
+        # private double-underscore var name that user code effectively
+        # never emits — so we strip anything between them (non-greedy,
+        # multiline-aware) to also handle width-wrap that inserted
+        # real \n breaks inside the echo.
+        text = text.gsub(
+          /[^\n]*\}; *__clacky_ec=\$\?.*?"\$__clacky_ec"[^\n]*\n?/m,
+          ""
+        )
+
+        # Pass 4: bare pivot with no printf tail at all (extreme
+        # truncation cut off everything after `__clacky_ec=$?`). Still a
+        # reliable fingerprint thanks to the `__clacky_ec` var name.
+        text = text.gsub(
+          /[^\n]*\}; *__clacky_ec=\$\?;?[^\n]*\n?/,
+          ""
+        )
+
         text
       end
 

data/lib/clacky/ui2/ui_controller.rb

@@ -1188,7 +1188,7 @@ module Clacky
             display_name = "#{type_badge}#{model_name} (#{masked_key})"
             choices << {
               name: display_name,
-              value: { action: :switch, index: idx }
+              value: { action: :switch, model_id: model["id"] }
             }
           end
           
@@ -1210,8 +1210,15 @@ module Clacky
           
           case result[:action]
           when :switch
-            current_config.switch_model(result[:index])
-            # Auto-save after switching
+            # CLI is a single-session context: when the user picks a model
+            # we treat it as "make this my default from now on". So:
+            #   1. switch this session's current model
+            #   2. move the global `type: "default"` marker to it
+            #   3. persist to config.yml so next CLI launch uses it
+            # (Web UI's per-session switch is different — it must NOT do
+            # steps 2 and 3, and uses switch_model_by_id directly.)
+            current_config.switch_model_by_id(result[:model_id])
+            current_config.set_default_model_by_id(result[:model_id])
             current_config.save
             # Return to indicate config changed (need to update client)
             return { action: :switch }
@@ -1228,10 +1235,12 @@ module Clacky
                 base_url: new_model[:base_url],
                 anthropic_format: anthropic_format
               )
-              # Auto-save after adding
-              current_config.save
-              # Set newly added model as default
-              current_config.switch_model(current_config.models.length - 1)
+              # CLI: adding a model implies the user wants to use it now and
+              # next launch. Switch this session to it AND set it as the
+              # global default, then persist.
+              new_id = current_config.models.last["id"]
+              current_config.switch_model_by_id(new_id)
+              current_config.set_default_model_by_id(new_id)
               current_config.save
               # Return to exit the menu
               return { action: :switch }

data/lib/clacky/version.rb

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