openclacky 0.8.9 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fbd7535e2cc98aadf0d9bbc3ff8dcc3db04669ba5c972ec00b41c338f1c3ae5
-  data.tar.gz: 345be84b2b010db47ccdd0454b0214463117519fe5d029440290c0187006ff4a
+  metadata.gz: 8a13cced61727911f2587013fa7f701863f8644ed62caaf235217be4dc306574
+  data.tar.gz: 9f9f1d42f482bf159099d2a49c8435f8bff176dc0126321cd980079297ff7078
 SHA512:
-  metadata.gz: 317f05f87355eb3c58da51dde828b6fafd3abbc7cc8bfa874c19445b5a783f7687ee84c7e8ddcf59573b7a554687ee8b2c9e5a8ed5d14993b6167fe5a656a881
-  data.tar.gz: ce669491b51cbff8f3fbdea2262d51d206377617d69ad981ac5025b824b86638d78d248ea6dcd89f4b9ecca92d042efa91b783dff220bec5c4ac348c8535b6d6
+  metadata.gz: 7b3841fdddb699185b6a0854a4413b2a604b5187235bc3a5cd408525a8bfd21746e8dab0a5e1b085fbbd928acad3f3bda845cd208d077b0420c6419815036168
+  data.tar.gz: 70feae263b9d3a43d3b199ffd26e40f3a79d61d8e56e27a77b9ab615a62cb9a483dcbbdde770cbe4117aee66db1aa93fcbfae6350aab7e744f8b7a8c80a9ab8d

data/CHANGELOG.md

@@ -7,9 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.8.9] - 2026-03-13
+## [0.9.1] - 2026-03-15
 
 ### Added
+- **Session context auto-injection**: the agent now automatically injects the current date and active model name into each conversation turn, so it always knows what day it is and which model it's running — helpful for time-sensitive tasks and multi-model setups
+- **Kimi/Moonshot extended thinking support**: reasoning content is now preserved and echoed back correctly in message history, fixing HTTP 400 errors when using Kimi's extended thinking API
+
+### Improved
+- **Browser tool install UX**: the `agent-browser` setup flow has been redesigned with a dedicated install script and clearer guidance, making first-time setup smoother
+
+## [0.9.0] - 2026-03-14
+
+### Added
+- **Version check and one-click upgrade in WebUI**: a version badge in the sidebar shows when a newer gem is available; clicking it opens an upgrade popover with a live install log and a restart button — no terminal needed
+- **Upgrade badge state machine**: the badge cycles through four visual states — amber pulsing dot (update available), spinning ring (installing), orange bouncing dot (restart needed), green check (restarted successfully)
 - **Markdown rendering in WebUI chat**: assistant responses are now rendered as rich markdown — headings, bold, code blocks, lists, and inline code are all formatted properly instead of displayed as raw text
 - **Session naming with auto-name and inline rename**: sessions are automatically named after the first exchange; users can double-click any session in the sidebar to rename it inline
 - **Session info bar with live status animation**: a slim bar below the chat header shows the session name, working directory, and a pulsing animation while the agent is thinking or executing tools
@@ -18,10 +29,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Idle compression in WebUI**: the agent now compresses long conversation history automatically when the session has been idle, keeping context efficient without manual intervention
 
 ### Improved
+- **Glob tool recursive search**: bare pattern names like `controller` are now automatically expanded to `**/*controller*` so searches always return results across all subdirectories
 - **Onboard flow**: soul setup is now non-blocking; the confirmation page is skipped for a faster first-run experience; onboard now asks the user to name the AI first, then collects the user profile
 - **Token usage display ordering**: the token usage line in WebUI now always appears below the assistant message bubble, not above it
+- **i18n coverage**: settings panel dynamically-rendered fields are now translated correctly at render time
 
 ### Fixed
+- **Upgrade popover stays open during install and reconnect**: the popover is now locked while a gem install or server restart is in progress, preventing accidental dismissal that would leave the badge stuck in a spinning state
+- **Session auto-name respects default placeholders**: session names are now assigned based on message history only, not the agent's internal name field, so placeholder names like "Session 1" no longer block the auto-naming logic
 - **Token usage line disappears after page refresh**: token usage data is now persisted in session history and correctly re-rendered when the page is reloaded
 - **Shell tool hangs on background commands**: commands containing `&` (background operator) no longer cause the shell tool to block indefinitely
 - **White flash on page load**: the page is now hidden until boot completes, preventing a flash of unstyled content or the wrong view on startup

data/lib/clacky/agent.rb

@@ -182,6 +182,9 @@ module Clacky
         @messages << system_message
       end
 
+      # Inject session context (date + model) if not yet present or date has changed
+      inject_session_context_if_needed
+
       # Format user message with images and files if provided
       user_content = format_user_content(user_input, images, files)
       @messages << { role: "user", content: user_content, task_id: task_id, created_at: Time.now.to_f }
@@ -423,6 +426,9 @@ module Clacky
       end
       # Store token_usage in the message so replay_history can re-emit it
       msg[:token_usage] = response[:token_usage] if response[:token_usage]
+      # Preserve reasoning_content so it is echoed back to APIs that require it
+      # (e.g. Kimi/Moonshot extended thinking — omitting it causes HTTP 400)
+      msg[:reasoning_content] = response[:reasoning_content] if response[:reasoning_content]
       @messages << msg
 
       response
@@ -871,6 +877,33 @@ module Clacky
       content
     end
 
+    # Inject a session context message (date + model) into the conversation.
+    # Only injects when:
+    #   1. No context message exists yet in this session, OR
+    #   2. The existing context is from a previous day (cross-day session)
+    # Marked with system_injected: true so existing filters (replay_history,
+    # get_recent_user_messages, etc.) automatically skip it.
+    # Cache-safe: always inserted just before the current user message,
+    # so no historical cache entries are ever invalidated.
+    private def inject_session_context_if_needed
+      today = Time.now.strftime("%Y-%m-%d")
+
+      # Find the last injected context message
+      last_ctx = @messages.reverse.find { |m| m[:session_context] }
+
+      # Skip if we already have a context for today
+      return if last_ctx && last_ctx[:context_date] == today
+
+      content = "[Session context: Today is #{Time.now.strftime('%Y-%m-%d, %A')}. Current model: #{current_model}]"
+      @messages << {
+        role: "user",
+        content: content,
+        system_injected: true,
+        session_context: true,
+        context_date: today
+      }
+    end
+
     # Track modified files for Time Machine snapshots
     # @param tool_name [String] Name of the tool that was executed
     # @param args [Hash] Arguments passed to the tool

data/lib/clacky/client.rb

@@ -659,13 +659,20 @@ module Clacky
           end
         end
 
-        {
+        result = {
           content: message["content"],
           tool_calls: parse_tool_calls(message["tool_calls"]),
           finish_reason: data["choices"].first["finish_reason"],
           usage: usage_data,
           raw_api_usage: raw_api_usage
         }
+
+        # Preserve reasoning_content if present (e.g. Kimi/Moonshot extended thinking).
+        # The API requires this field to be echoed back in the message history on
+        # subsequent requests, otherwise it returns HTTP 400.
+        result[:reasoning_content] = message["reasoning_content"] if message["reasoning_content"]
+
+        result
       else
         raise_error(response)
       end

data/lib/clacky/server/http_server.rb

@@ -131,10 +131,20 @@ module Clacky
         @agent_config   = agent_config
         @client_factory = client_factory  # callable: -> { Clacky::Client.new(...) }
         @brand_test     = brand_test      # when true, skip remote API calls for license activation
+        # Capture the absolute path of the entry script and original ARGV at startup,
+        # so api_restart can re-exec the correct binary even if cwd changes later.
+        @restart_script = File.expand_path($0)
+        @restart_argv   = ARGV.dup
         @registry        = SessionRegistry.new
         @session_manager = Clacky::SessionManager.new
         @ws_clients      = {}  # session_id => [WebSocketConnection, ...]
         @ws_mutex        = Mutex.new
+        # Version cache: { latest: "x.y.z", checked_at: Time }
+        @version_cache   = nil
+        @version_mutex   = Mutex.new
+        # Version cache: { latest: "x.y.z", checked_at: Time }
+        @version_cache   = nil
+        @version_mutex   = Mutex.new
         @scheduler       = Scheduler.new(
           session_registry: @registry,
           session_builder:  method(:build_session)
@@ -264,6 +274,9 @@ module Clacky
         when ["GET",    "/api/brand"]             then api_brand_info(res)
         when ["GET",    "/api/channels"]          then api_list_channels(res)
         when ["POST",   "/api/upload"]            then api_upload_file(req, res)
+        when ["GET",    "/api/version"]           then api_get_version(res)
+        when ["POST",   "/api/version/upgrade"]   then api_upgrade_version(req, res)
+        when ["POST",   "/api/restart"]           then api_restart(req, res)
         else
           if method == "POST" && path.match?(%r{^/api/channels/[^/]+/test$})
             platform = path.sub("/api/channels/", "").sub("/test", "")
@@ -591,6 +604,111 @@ module Clacky
         json_response(res, 200, brand.to_h)
       end
 
+      # ── Version API ───────────────────────────────────────────────────────────
+
+      # GET /api/version
+      # Returns current version and latest version from RubyGems (cached for 1 hour).
+      def api_get_version(res)
+        current = Clacky::VERSION
+        latest  = fetch_latest_version_cached
+        json_response(res, 200, {
+          current:      current,
+          latest:       latest,
+          needs_update: latest ? version_older?(current, latest) : false
+        })
+      end
+
+      # POST /api/version/upgrade
+      # Runs `gem update openclacky --no-document` via Clacky::Tools::Shell (login shell)
+      # in a background thread, streaming output via WebSocket broadcast.
+      # On success, re-execs the process so the new gem version is loaded.
+      def api_upgrade_version(req, res)
+        json_response(res, 202, { ok: true, message: "Upgrade started" })
+
+        Thread.new do
+          begin
+            broadcast_all(type: "upgrade_log", line: "Starting upgrade: gem update openclacky --no-document\n")
+
+            shell  = Clacky::Tools::Shell.new
+            result = shell.execute(command: "gem update openclacky --no-document",
+                                   soft_timeout: 300, hard_timeout: 600)
+            output  = [result[:stdout], result[:stderr]].join
+            success = result[:exit_code] == 0
+
+            broadcast_all(type: "upgrade_log", line: output)
+
+            if success
+              broadcast_all(type: "upgrade_log", line: "\n✓ Upgrade successful! Please restart the server to apply the new version.\n")
+              broadcast_all(type: "upgrade_complete", success: true)
+            else
+              broadcast_all(type: "upgrade_log", line: "\n✗ Upgrade failed. Please try manually: gem update openclacky\n")
+              broadcast_all(type: "upgrade_complete", success: false)
+            end
+          rescue StandardError => e
+            broadcast_all(type: "upgrade_log", line: "\n✗ Error during upgrade: #{e.message}\n")
+            broadcast_all(type: "upgrade_complete", success: false)
+          end
+        end
+      end
+
+      # POST /api/restart
+      # Re-execs the current process so the newly installed gem version is loaded.
+      # Uses the absolute script path captured at startup to avoid relative-path issues.
+      # Responds 200 first, then waits briefly for WEBrick to flush the response before exec.
+      def api_restart(req, res)
+        json_response(res, 200, { ok: true, message: "Restarting…" })
+
+        script = @restart_script
+        argv   = @restart_argv
+        Thread.new do
+          sleep 0.5  # Let WEBrick flush the HTTP response
+          Clacky::Logger.info("[Restart] exec: #{RbConfig.ruby} #{script} #{argv.join(' ')}")
+          exec(RbConfig.ruby, script, *argv)
+        end
+      end
+
+      # Fetch the latest gem version using `gem list -r`, with a 1-hour in-memory cache.
+      # Uses Clacky::Tools::Shell (login shell) so rbenv/mise shims and gem mirrors work correctly.
+      private def fetch_latest_version_cached
+        @version_mutex.synchronize do
+          now = Time.now
+          if @version_cache && (now - @version_cache[:checked_at]) < 3600
+            return @version_cache[:latest]
+          end
+        end
+
+        # Fetch outside the mutex to avoid blocking other requests
+        latest = fetch_latest_version_from_gem
+
+        @version_mutex.synchronize do
+          @version_cache = { latest: latest, checked_at: Time.now }
+        end
+
+        latest
+      end
+
+      # Query the latest openclacky version via `gem list -r openclacky`.
+      # Runs through login shell so gem source mirrors configured via rbenv/mise work correctly.
+      # Output format: "openclacky (0.9.0)"
+      private def fetch_latest_version_from_gem
+        shell  = Clacky::Tools::Shell.new
+        result = shell.execute(command: "gem list -r openclacky", soft_timeout: 15, hard_timeout: 30)
+        return nil unless result[:exit_code] == 0
+
+        out   = result[:stdout].to_s
+        match = out.match(/^openclacky\s+\(([^)]+)\)/)
+        match ? match[1].strip : nil
+      rescue StandardError
+        nil
+      end
+
+      # Returns true if version string `a` is strictly older than `b`.
+      private def version_older?(a, b)
+        Gem::Version.new(a) < Gem::Version.new(b)
+      rescue ArgumentError
+        false
+      end
+
       # ── Channel API ───────────────────────────────────────────────────────────
 
       # GET /api/channels
@@ -1354,8 +1472,10 @@ module Clacky
         end
         content = [content, *file_refs].join("\n") unless file_refs.empty?
 
-        # Auto-name the session from the first user message (before agent starts running)
-        if agent.name.empty? && agent.messages.empty?
+        # Auto-name the session from the first user message (before agent starts running).
+        # Check messages.empty? only — agent.name may already hold a default placeholder
+        # like "Session 1" assigned at creation time, so it's not a reliable signal.
+        if agent.messages.empty?
           auto_name = content.gsub(/\s+/, " ").strip[0, 30]
           auto_name += "…" if content.strip.length > 30
           agent.rename(auto_name)
@@ -1635,15 +1755,23 @@ module Clacky
 
         pid = File.read(pid_file).strip.to_i
         return if pid <= 0
+        # After exec-restart, the new process inherits the same PID as the old one.
+        # Skip sending TERM to ourselves — we are already the new server.
+        if pid == Process.pid
+          Clacky::Logger.info("[Server] exec-restart detected (PID=#{pid}), skipping self-kill.")
+          return
+        end
 
         begin
           Process.kill("TERM", pid)
+          Clacky::Logger.info("[Server] Stopped existing server (PID=#{pid}) on port #{port}.")
           puts "Stopped existing server (PID: #{pid}) on port #{port}."
           # Give it a moment to release the port
           sleep 0.5
         rescue Errno::ESRCH
-          # Process already gone — nothing to do
+          Clacky::Logger.info("[Server] Existing server PID=#{pid} already gone.")
         rescue Errno::EPERM
+          Clacky::Logger.warn("[Server] Could not stop existing server (PID=#{pid}) — permission denied.")
           puts "Could not stop existing server (PID: #{pid}) — permission denied."
         ensure
           File.delete(pid_file) if File.exist?(pid_file)

data/lib/clacky/tools/browser.rb

@@ -13,14 +13,24 @@ module Clacky
       self.tool_description = <<~DESC
         Browser automation for login-related operations (sign-in, OAuth, form submission requiring session). For simple page fetch or search, prefer web_fetch or web_search instead.
 
-        isolated param: true = built-in browser (default, works immediately, login persists). false = user's Chrome (keeps cookies/login, needs one-time debug setup; opens URLs in new tab).
+        isolated: true = built-in browser (default, no setup, login persists). false = user's Chrome (keeps cookies/login, needs one-time debug setup; opens URLs in new tab).
 
-        WORKFLOW:
-        - Default: use isolated=true (built-in browser). No setup, works immediately.
-        - If the user explicitly wants their Chrome (e.g. "use my Chrome"), set isolated=false. We auto-open chrome://inspect/#remote-debugging when needed — guide user to enable the toggle. When opening URLs, we use a new tab to avoid replacing the user's current page.
+        SNAPSHOT — always run before interacting with a page. Refs (@e1, @e2...) expire after page changes, always re-snapshot before acting on a changed page:
+        - 'snapshot -i -C' — interactive + cursor-clickable elements (recommended default)
+        - 'snapshot -i' — interactive elements only (faster, for simple forms)
+        - 'snapshot' — full accessibility tree (when above miss elements)
 
-        Commands: 'open <url>', 'snapshot -i', 'click @e1', 'fill @e2 "text"', etc.
-        IMPORTANT: Always use 'snapshot -i' to inspect page state. NEVER use 'screenshot' without explicit user permission — it costs significantly more tokens. If snapshot is insufficient, tell the user and ask if they want a screenshot.
+        ELEMENT SELECTION — prefer in this order:
+        1. Refs: 'click @e1', 'fill @e2 "text"'
+        2. Semantic find: 'find text "Submit" click', 'find role button "Login" click', 'find label "Email" fill "user@example.com"'
+        3. CSS: 'click "#submit-btn"'
+
+        OTHER COMMANDS:
+        - 'open <url>', 'back', 'reload', 'press Enter', 'key Control+a'
+        - 'scroll down/up', 'scrollintoview @e1', 'wait @e1', 'wait --text "..."', 'wait --load networkidle'
+        - 'dialog accept/dismiss', 'tab new <url>', 'tab <n>'
+
+        SCREENSHOT: NEVER call on your own — costs far more tokens than snapshot. Last resort only. Ask user first: "Screenshots cost more tokens. Approve?" When approved: 'screenshot --screenshot-format jpeg --screenshot-quality 50'.
       DESC
       self.tool_category = "web"
       self.tool_parameters = {
@@ -47,11 +57,29 @@ module Clacky
       CHROME_DEBUG_PORT = 9222
       BROWSER_COMMAND_TIMEOUT = 30
       CHROME_DEBUG_PAGE = "chrome://inspect/#remote-debugging"
+      MIN_AGENT_BROWSER_VERSION = "0.20.0"
 
       def execute(command:, session: nil, isolated: nil, working_dir: nil)
-        unless agent_browser_installed?
-          install_result = auto_install_agent_browser
-          return install_result if install_result[:error]
+        # Handle explicit install command
+        if command.strip == "install"
+          return do_install_agent_browser
+        end
+
+        if !agent_browser_installed?
+          return {
+            error: "agent-browser not installed",
+            message: "agent-browser is required for browser automation but is not installed.",
+            instructions: "Tell the user: 'agent-browser is not installed. It's required for browser automation. Run `browser(command: \"install\")` to install it — this may take a minute. Would you like me to install it now?' Wait for user confirmation before calling install."
+          }
+        end
+
+        if agent_browser_outdated?
+          current = `agent-browser --version 2>/dev/null`.strip.split.last
+          return {
+            error: "agent-browser version too old",
+            message: "agent-browser #{current} is installed but version >= #{MIN_AGENT_BROWSER_VERSION} is required.",
+            instructions: "Tell the user: 'agent-browser needs to be upgraded from #{current} to #{MIN_AGENT_BROWSER_VERSION}+. Run `browser(command: \"install\")` to upgrade — this may take a minute. Would you like me to upgrade it now?' Wait for user confirmation before calling install."
+          }
         end
 
         # Default to built-in browser (isolated=true). Only use user's Chrome when explicitly isolated=false.
@@ -94,12 +122,6 @@ module Clacky
           result = Shell.new.execute(command: full_command, hard_timeout: BROWSER_COMMAND_TIMEOUT, working_dir: working_dir)
         end
 
-        if playwright_missing?(result)
-          pw_result = install_playwright_chromium
-          return pw_result if pw_result[:error]
-          result = Shell.new.execute(command: full_command, hard_timeout: BROWSER_COMMAND_TIMEOUT, working_dir: working_dir)
-        end
-
         if use_auto_connect && !result[:success] && connection_error?(result)
           if we_launched_chrome
             result = Shell.new.execute(command: full_command, hard_timeout: BROWSER_COMMAND_TIMEOUT, working_dir: working_dir)
@@ -363,52 +385,23 @@ module Clacky
         !!find_in_path(AGENT_BROWSER_BIN)
       end
 
-      def auto_install_agent_browser
-        npm = find_or_install_npm
-        unless npm
-          return {
-            error: "agent-browser not installed",
-            message: "agent-browser is required for browser automation but is not installed. " \
-              "Node.js not found; tried to install via mise but failed.\n\n" \
-              "Please run: mise install node@22 && mise use -g node@22"
-          }
-        end
-
-        result = Shell.new.execute(command: "#{npm} install -g agent-browser", hard_timeout: 120)
-        unless result[:success]
-          return {
-            error: "Failed to auto-install agent-browser",
-            message: "npm install -g agent-browser failed: #{result[:stderr]}\n\nPlease run it manually."
-          }
-        end
-
-        {}
-      end
-
-      def find_or_install_npm
-        npm = find_in_path("npm")
-        return npm if npm
-
-        mise = find_mise_bin
-        return nil unless mise
-
-        path = `#{Shellwords.escape(mise)} which npm 2>/dev/null`.strip
-        return path if path && !path.empty? && File.executable?(path)
-        system(mise, "install", "node@22", out: File::NULL, err: File::NULL)
-        system(mise, "use", "-g", "node@22", out: File::NULL, err: File::NULL)
-
-        path = `#{Shellwords.escape(mise)} which npm 2>/dev/null`.strip
-        return path if path && !path.empty? && File.executable?(path)
-
-        nil
+      def agent_browser_outdated?
+        version = `agent-browser --version 2>/dev/null`.strip.split.last
+        return false if version.nil? || version.empty?
+        Gem::Version.new(version) < Gem::Version.new(MIN_AGENT_BROWSER_VERSION)
+      rescue StandardError
+        false
       end
 
-      def find_mise_bin
-        mise = find_in_path("mise")
-        return mise if mise
-
-        candidate = "#{Dir.home}/.local/bin/mise"
-        File.executable?(candidate) ? candidate : nil
+      def do_install_agent_browser
+        script = File.expand_path("../../../../scripts/install_agent_browser.sh", __FILE__)
+        result = Shell.new.execute(command: "bash #{Shellwords.escape(script)}", hard_timeout: 180)
+        if result[:success]
+          version = `agent-browser --version 2>/dev/null`.strip.split.last
+          { success: true, message: "agent-browser #{version} installed successfully. You can now use browser commands." }
+        else
+          { error: "Failed to install agent-browser", message: result[:stdout].to_s.strip }
+        end
       end
 
       def command_name_for_temp(command)
@@ -445,25 +438,6 @@ module Clacky
         { content: first_part.join + notice, temp_file: temp_file }
       end
 
-      def playwright_missing?(result)
-        output = "#{result[:stdout]}#{result[:stderr]}"
-        output.include?("Executable doesn't exist") ||
-          output.include?("Please run the following command to download new browsers")
-      end
-
-      def install_playwright_chromium
-        playwright = find_in_path("playwright")
-        cmd = playwright ? "#{playwright} install chromium" : "npx playwright install chromium"
-
-        result = Shell.new.execute(command: cmd, hard_timeout: 300)
-        unless result[:success]
-          return {
-            error: "Failed to install Playwright Chromium",
-            message: "Automatic browser installation failed. Please run manually:\n  npx playwright install chromium"
-          }
-        end
-        {}
-      end
     end
   end
 end

data/lib/clacky/tools/glob.rb

@@ -63,11 +63,22 @@ module Clacky
             ignored: 0
           }
 
+          # Auto-expand bare patterns (no slash, no **) to recursive search.
+          # e.g. "*install*" -> "**/*install*", "*.rb" -> "**/*.rb"
+          # This avoids surprising empty results when files are in subdirectories.
+          effective_pattern = if !File.absolute_path?(pattern) &&
+                                  !pattern.include?("/") &&
+                                  !pattern.start_with?("**")
+                                "**/#{pattern}"
+                              else
+                                pattern
+                              end
+
           # Build full pattern - handle absolute paths correctly
-          full_pattern = if File.absolute_path?(pattern)
-                          pattern
+          full_pattern = if File.absolute_path?(effective_pattern)
+                          effective_pattern
                         else
-                          File.join(base_path, pattern)
+                          File.join(base_path, effective_pattern)
                         end
           # Always-ignored directory names that should never appear in results
           always_ignored_dirs = Clacky::Utils::FileIgnoreHelper::ALWAYS_IGNORED_DIRS

data/lib/clacky/version.rb

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