openclacky 1.0.4 → 1.1.0

data/lib/clacky/server/http_server.rb

@@ -163,7 +163,8 @@ module Clacky
         @session_manager = Clacky::SessionManager.new(sessions_dir: sessions_dir)
         @registry        = SessionRegistry.new(
           session_manager:  @session_manager,
-          session_restorer: method(:build_session_from_data)
+          session_restorer: method(:build_session_from_data),
+          agent_config:     @agent_config
         )
         @ws_clients      = {}   # session_id => [WebSocketConnection, ...]
         @all_ws_conns    = []   # every connected WS client, regardless of session subscription
@@ -244,7 +245,15 @@ module Clacky
             Clacky::Logger.warn("[HttpServer] Forced exit after graceful shutdown timeout.")
             exit!(0)
           end
-          # Stop channel and browser managers in parallel to minimize shutdown time.
+          # Detach the inherited (shared) listen socket BEFORE shutdown so that
+          # WEBrick's cleanup_listener does not call shutdown(SHUT_RDWR)+close on
+          # it — that would propagate to every process sharing the underlying
+          # kernel socket (Master + new worker), breaking subsequent accept()
+          # on Linux. macOS's BSD stack tolerates this; Linux does not.
+          if @inherited_socket && server.listeners.include?(@inherited_socket)
+            server.listeners.delete(@inherited_socket)
+            Clacky::Logger.info("[HttpServer PID=#{Process.pid}] detached inherited socket fd=#{@inherited_socket.fileno} before shutdown")
+          end
           t1 = Thread.new { @channel_manager.stop rescue nil }
           t2 = Thread.new { Clacky::BrowserManager.instance.stop rescue nil }
           t1.join(1.5)
@@ -415,6 +424,9 @@ module Clacky
           elsif method == "POST" && path.match?(%r{^/api/channels/[^/]+/test$})
             platform = path.sub("/api/channels/", "").sub("/test", "")
             api_test_channel(platform, req, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/channels/[^/]+/enabled$})
+            platform = path.sub("/api/channels/", "").sub("/enabled", "")
+            api_toggle_channel(platform, req, res)
           elsif method == "POST" && path.start_with?("/api/channels/")
             platform = path.sub("/api/channels/", "")
             api_save_channel(platform, req, res)
@@ -525,7 +537,7 @@ module Clacky
         profile = "general" if profile.empty?
 
         # Optional source; defaults to :manual. Accept "system" for skill-launched sessions
-        # (e.g. /onboard, /browser-setup, /channel-setup).
+        # (e.g. /onboard, /browser-setup, /channel-manager).
         raw_source = body["source"].to_s.strip
         source = %w[manual cron channel setup].include?(raw_source) ? raw_source.to_sym : :manual
 
@@ -1005,10 +1017,14 @@ module Clacky
       def api_get_version(res)
         current = Clacky::VERSION
         latest  = fetch_latest_version_cached
+        brand   = Clacky::BrandConfig.load
+        cli_cmd = brand.branded? && brand.package_name && !brand.package_name.empty? ? brand.package_name : "openclacky"
         json_response(res, 200, {
           current:      current,
           latest:       latest,
-          needs_update: latest ? version_older?(current, latest) : false
+          needs_update: latest ? version_older?(current, latest) : false,
+          launcher:     ENV["CLACKY_LAUNCHER"] || "cli",
+          cli_command:  cli_cmd
         })
       end
 
@@ -1608,6 +1624,7 @@ module Clacky
 
         # Record when the token was last updated so clients can detect re-login
         fields[:token_updated_at] = Time.now.to_i if platform == :weixin && fields.key?(:token)
+        fields[:token_updated_at] = Time.now.to_i if platform == :discord && fields.key?(:bot_token)
 
         # Validate credentials against live API before persisting.
         # Merge with existing config so partial updates (e.g. allowed_users only) still validate correctly.
@@ -1648,6 +1665,34 @@ module Clacky
         json_response(res, 422, { ok: false, error: e.message })
       end
 
+      # PATCH /api/channels/:platform/enabled
+      # Body: { enabled: true|false }
+      # Toggles the platform on/off without touching credentials.
+      # Enabling requires the platform to already be configured.
+      def api_toggle_channel(platform, req, res)
+        platform = platform.to_sym
+        enabled  = parse_json_body(req)["enabled"] == true
+
+        config = Clacky::ChannelConfig.load
+
+        if enabled
+          unless config.platform_config(platform)
+            json_response(res, 422, { ok: false, error: "Platform is not configured yet" })
+            return
+          end
+          config.enable_platform(platform)
+        else
+          config.disable_platform(platform)
+        end
+
+        config.save
+        @channel_manager.reload_platform(platform, config)
+
+        json_response(res, 200, { ok: true, enabled: config.enabled?(platform) })
+      rescue StandardError => e
+        json_response(res, 422, { ok: false, error: e.message })
+      end
+
       # POST /api/channels/:platform/test
       # Body: { fields... }  (credentials to test — NOT saved)
       # Tests connectivity using the provided credentials without persisting.
@@ -1689,6 +1734,24 @@ module Clacky
             has_token:         !raw["token"].to_s.strip.empty?,
             token_updated_at:  raw["token_updated_at"]  # Unix timestamp, nil if never set
           }
+        when :discord
+          {
+            allowed_users:    raw["allowed_users"] || [],
+            has_token:        !raw["bot_token"].to_s.strip.empty?,
+            token_updated_at: raw["token_updated_at"]
+          }
+        when :telegram
+          {
+            base_url:      raw["base_url"] || Clacky::Channel::Adapters::Telegram::ApiClient::DEFAULT_BASE_URL,
+            parse_mode:    raw.key?("parse_mode") ? raw["parse_mode"] : "Markdown",
+            allowed_users: raw["allowed_users"] || [],
+            has_token:     !raw["bot_token"].to_s.strip.empty?
+          }
+        when :dingtalk
+          {
+            client_id:     raw["client_id"] || "",
+            allowed_users: raw["allowed_users"] || []
+          }
         else
           {}
         end
@@ -3459,6 +3522,14 @@ module Clacky
       # session persistence, and idle compression timer lifecycle.
       # Yields to the caller to perform the actual agent.run call.
       private def run_agent_task(session_id, agent, &task)
+        if @registry.running_full?
+          broadcast(session_id, { type: "error", session_id: session_id,
+                                  message: "Too many concurrent tasks (max #{@registry.max_running_agents}), please try again later" })
+          return
+        end
+
+        @registry.evict_excess_idle!
+
         idle_timer = nil
         @registry.with_session(session_id) { |s| idle_timer = s[:idle_timer] }
 

data/lib/clacky/server/server_master.rb

@@ -275,35 +275,57 @@ module Clacky
         puts ""
       end
 
+      # Scan all fallback port PID files to prevent duplicate masters
+      # when a previous instance bound to a non-default fallback port.
       def kill_existing_master
-        return unless File.exist?(pid_file_path)
+        max_port = (@port == 7070) ? (@port + 5) : @port
+        (@port..max_port).each do |port|
+          kill_master_on_port(port)
+        end
+      end
 
-        pid = File.read(pid_file_path).strip.to_i
-        return if pid <= 0
+      private def kill_master_on_port(port)
+        path = File.join(Dir.tmpdir, "clacky-master-#{port}.pid")
+        return unless File.exist?(path)
+
+        pid = File.read(path).strip.to_i
+        if pid <= 0
+          File.delete(path) rescue nil
+          return
+        end
 
         begin
           Process.kill("TERM", pid)
-          Clacky::Logger.info("[Master] Sent TERM to existing master (PID=#{pid}), waiting up to 3s...")
+          Clacky::Logger.info("[Master] Sent TERM to existing master (PID=#{pid}, port=#{port}), waiting...")
 
-          unless port_free_within?(5)
-            Clacky::Logger.warn("[Master] Port #{@port} still in use after 5s, sending KILL to PID=#{pid}...")
+          deadline = Time.now + 5
+          until process_dead?(pid) || Time.now > deadline
+            sleep 0.1
+          end
+
+          unless process_dead?(pid)
+            Clacky::Logger.warn("[Master] PID=#{pid} still alive after 5s, sending KILL...")
             Process.kill("KILL", pid) rescue Errno::ESRCH
-            unless port_free_within?(2)
-              Clacky::Logger.error("[Master] Port #{@port} still in use after KILL, giving up.")
-              exit(1)
-            end
           end
 
-          Clacky::Logger.info("[Master] Port #{@port} is now free.")
+          Clacky::Logger.info("[Master] Existing master PID=#{pid} (port=#{port}) stopped.")
         rescue Errno::ESRCH
           Clacky::Logger.info("[Master] Existing master PID=#{pid} already gone.")
         rescue Errno::EPERM
           Clacky::Logger.warn("[Master] Could not stop existing master (PID=#{pid}) — permission denied.")
-          exit(1)
         ensure
-          File.delete(pid_file_path) if File.exist?(pid_file_path)
+          File.delete(path) if File.exist?(path)
         end
       end
+
+      private def process_dead?(pid)
+        Process.kill(0, pid)
+        false
+      rescue Errno::ESRCH
+        true
+      rescue Errno::EPERM
+        false
+      end
     end
   end
 end

data/lib/clacky/server/session_registry.rb

@@ -18,13 +18,12 @@ module Clacky
     class SessionRegistry
       SESSION_TIMEOUT = 24 * 60 * 60 # 24 hours of inactivity before cleanup
 
-      # session_manager: Clacky::SessionManager instance
-      # session_restorer: callable(session_data) → session_id — builds agent + wires into registry
-      def initialize(session_manager: nil, session_restorer: nil)
+      def initialize(session_manager: nil, session_restorer: nil, agent_config:)
         @sessions         = {}
         @mutex            = Mutex.new
         @session_manager  = session_manager
         @session_restorer = session_restorer
+        @agent_config     = agent_config
         # Tracks sessions currently being restored from disk.
         # Other threads calling ensure() for the same id will wait via @restore_cond
         # instead of seeing a half-built session (agent=nil).
@@ -322,6 +321,58 @@ module Clacky
         end
       end
 
+      def count_by_status(status)
+        @mutex.synchronize do
+          @sessions.count { |_, s| s[:status] == status }
+        end
+      end
+
+      def max_running_agents
+        @agent_config.max_running_agents
+      end
+
+      def max_idle_agents
+        @agent_config.max_idle_agents
+      end
+
+      def running_full?
+        count_by_status(:running) >= max_running_agents
+      end
+
+      # Evict oldest idle agents beyond MAX_IDLE_AGENTS.
+      # Persists session data to disk before releasing the agent from memory.
+      def evict_excess_idle!
+        to_evict = []
+
+        @mutex.synchronize do
+          idle = @sessions.select { |_, s| s[:status] == :idle && s[:agent] }
+                   .sort_by { |_, s| s[:updated_at] || Time.at(0) }
+
+          while idle.size > max_idle_agents
+            id, session = idle.shift
+            to_evict << [id, session]
+          end
+        end
+
+        to_evict.each { |id, session| persist_and_release(id, session) }
+      end
+
+      private def persist_and_release(id, session)
+        agent = session[:agent]
+        @session_manager&.save(agent.to_session_data(status: :success)) if agent
+
+        @mutex.synchronize do
+          s = @sessions[id]
+          next unless s
+          s[:idle_timer]&.cancel
+          s[:agent] = nil
+          s[:ui] = nil
+          s[:idle_timer] = nil
+          s[:thread] = nil
+          @sessions.delete(id)
+        end
+      end
+
       # Build a summary hash for API responses (for in-registry sessions).
       # Used when we need live agent fields (name, cost, etc.) after ensure().
       def session_summary(session_id)

data/lib/clacky/server/web_ui_controller.rb

@@ -87,7 +87,13 @@ module Clacky
       def show_assistant_message(content, files:)
         return if (content.nil? || content.to_s.strip.empty?) && files.empty?
 
-        emit("assistant_message", content: content.to_s, files: files)
+        # Rewrite local image paths (file:// and bare absolute) to /api/local-image
+        # proxy URLs only for the browser, which runs on http://localhost and is
+        # blocked by browser security policy from loading file:// directly.
+        # Channel subscribers receive the original content so they can deliver
+        # local images as native attachments via send_file().
+        web_content = Clacky::Utils::FileProcessor.rewrite_local_image_urls(content.to_s)
+        emit("assistant_message", content: web_content, files: files)
         forward_to_subscribers { |sub| sub.show_assistant_message(content, files: files) }
       end
 

data/lib/clacky/telemetry.rb

@@ -67,22 +67,7 @@ module Clacky
       end
 
       private def resolve_device_id(brand)
-        if brand.device_id && !brand.device_id.empty?
-          brand.device_id
-        else
-          generate_anonymous_device_id
-        end
-      end
-
-      # Generate an anonymous device fingerprint that is stable for the same
-      # machine/user but does not reveal identifiable information.
-      private def generate_anonymous_device_id
-        components = [
-          Socket.gethostname,
-          ENV["USER"] || ENV["USERNAME"] || "",
-          RUBY_PLATFORM
-        ]
-        Digest::SHA256.hexdigest(components.join(":"))
+        brand.device_id
       end
 
       # Send a POST to the telemetry endpoint in a background thread.

data/lib/clacky/tools/browser.rb

@@ -108,7 +108,6 @@ module Clacky
         if action == "screenshot" && result[:image_data]
           mime_type       = result[:mime_type] || "image/png"
           image_data      = result[:image_data]
-          data_url        = "data:#{mime_type};base64,#{image_data}"
           original_path   = result[:original_path]
           compressed_path = result[:compressed_path]
 
@@ -118,10 +117,14 @@ module Clacky
                     "\n- Compressed (800px, sent to AI): #{compressed_path || 'unavailable'}"
           end
 
-          return [
-            { type: "text",      text:      text },
-            { type: "image_url", image_url: { url: data_url } }
-          ]
+          return {
+            content_string: text,
+            image_inject: {
+              mime_type: mime_type,
+              base64_data: image_data,
+              path: compressed_path || original_path
+            }
+          }
         end
 
         output = result[:output].to_s

data/lib/clacky/tools/glob.rb

@@ -52,11 +52,6 @@ module Clacky
         begin
           expanded_path = base_path
 
-          # Initialize gitignore parser
-          gitignore_path = Clacky::Utils::FileIgnoreHelper.find_gitignore(expanded_path)
-          gitignore = gitignore_path ? Clacky::GitignoreParser.new(gitignore_path) : nil
-
-          # Track skipped files
           skipped = {
             binary: 0,
             too_large: 0,
@@ -64,8 +59,6 @@ module Clacky
           }
 
           # 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?("**")
@@ -74,48 +67,28 @@ module Clacky
                                 pattern
                               end
 
-          # Build full pattern - handle absolute paths correctly
-          full_pattern = if File.absolute_path?(effective_pattern)
-                          effective_pattern
-                        else
-                          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
-
-          all_matches = Dir.glob(full_pattern, File::FNM_DOTMATCH)
-                           .map { |p| p.encoding == Encoding::UTF_8 && p.valid_encoding? ? p : p.encode("UTF-8", invalid: :replace, undef: :replace, replace: "\u{FFFD}") }
-                           .reject { |path| File.directory?(path) }
-                           .reject { |path| path.end_with?(".", "..") }
-                           .reject do |path|
-                             # Fast path: reject files inside always-ignored dirs by path component
-                             parts = path.split(File::SEPARATOR)
-                             parts.any? { |part| always_ignored_dirs.include?(part) }
-                           end
-
-          # Filter out ignored, binary, and too large files
-          matches = all_matches.select do |file|
-            # Skip if file should be ignored (unless it's a config file)
-            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) && 
-               !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
-              skipped[:ignored] += 1
-              next false
+          fnmatch_flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+          matches = []
+          Clacky::Utils::FileIgnoreHelper.walk_files(expanded_path, skipped: skipped) do |file|
+            relative = file[(expanded_path.length + 1)..]
+
+            unless File.fnmatch(effective_pattern, relative, fnmatch_flags)
+              next
             end
 
-            # Skip binary files (but allow known document types like PDF/Office)
             if Clacky::Utils::FileProcessor.binary_file_path?(file) &&
                !Clacky::Utils::FileProcessor.glob_allowed_binary?(file)
               skipped[:binary] += 1
-              next false
+              next
             end
 
-            # Skip files that are too large
             if File.size(file) > MAX_FILE_SIZE
               skipped[:too_large] += 1
-              next false
+              next
             end
 
-            true
+            matches << file
           end
 
           # Sort by modification time (most recent first)

data/lib/clacky/tools/grep.rb

@@ -100,10 +100,6 @@ module Clacky
           regex_options = case_insensitive ? Regexp::IGNORECASE : 0
           regex = Regexp.new(pattern, regex_options)
 
-          # Initialize gitignore parser
-          gitignore_path = Clacky::Utils::FileIgnoreHelper.find_gitignore(expanded_path)
-          gitignore = gitignore_path ? Clacky::GitignoreParser.new(gitignore_path) : nil
-
           results = []
           total_matches = 0
           files_searched = 0
@@ -114,29 +110,24 @@ module Clacky
           }
           truncation_reason = nil
 
-          # Get files to search
           files = if File.file?(expanded_path)
                     [expanded_path]
                   else
-                    Dir.glob(File.join(expanded_path, file_pattern))
-                       .select { |f| File.file?(f) }
+                    fnmatch_flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+                    collected = []
+                    Clacky::Utils::FileIgnoreHelper.walk_files(expanded_path, skipped: skipped) do |f|
+                      relative = f[(expanded_path.length + 1)..]
+                      collected << f if File.fnmatch(file_pattern, relative, fnmatch_flags)
+                    end
+                    collected
                   end
 
-          # Search each file
           files.each do |file|
-            # Check if we've searched enough files
             if files_searched >= max_files_to_search
               truncation_reason ||= "max_files_to_search limit reached"
               break
             end
 
-            # Skip if file should be ignored (unless it's a config file)
-            if Clacky::Utils::FileIgnoreHelper.should_ignore_file?(file, expanded_path, gitignore) &&
-               !Clacky::Utils::FileIgnoreHelper.is_config_file?(file)
-              skipped[:ignored] += 1
-              next
-            end
-
             # Skip binary files
             if Clacky::Utils::FileProcessor.binary_file_path?(file)
               skipped[:binary] += 1

data/lib/clacky/ui2/markdown_renderer.rb

@@ -26,7 +26,7 @@ module Clacky
 
           parsed
         rescue StandardError => e
-          # Fallback to plain content if rendering fails
+          warn "[markdown] render failed: #{e.class}: #{e.message}" if ENV["CLACKY_DEBUG"]
           content
         end
 

data/lib/clacky/ui2/ui_controller.rb

@@ -733,8 +733,9 @@ module Clacky
         @legacy_progress_handles ||= {}
 
         if phase.to_s == "done"
-          handle = @legacy_progress_handles.delete(type)
+          handle = @legacy_progress_handles[type]
           handle&.finish(final_message: message)
+          @legacy_progress_handles.delete(type)
           return
         end
 

data/lib/clacky/utils/file_ignore_helper.rb

@@ -116,6 +116,55 @@ module Clacky
         CONFIG_FILE_PATTERNS.any? { |pattern| file.match?(pattern) }
       end
 
+      # Walk a directory tree, pruning ignored directories early.
+      # Yields each non-ignored file path. Supports nested .gitignore files.
+      # @param skipped [Hash, nil] If provided, increments :ignored for each gitignore-skipped entry.
+      def self.walk_files(base_path, gitignore: nil, skipped: nil, &block)
+        return enum_for(:walk_files, base_path, gitignore: gitignore, skipped: skipped) unless block_given?
+
+        root_gitignore = gitignore || begin
+          gi_path = find_gitignore(base_path)
+          gi_path ? Clacky::GitignoreParser.new(gi_path) : nil
+        end
+
+        _walk_recursive(base_path, base_path, root_gitignore, skipped, &block)
+      end
+
+      def self._walk_recursive(dir, base_path, gitignore, skipped, &block)
+        child_gitignore_path = File.join(dir, ".gitignore")
+        if dir != base_path && File.exist?(child_gitignore_path)
+          gitignore ||= Clacky::GitignoreParser.new(nil)
+          relative_dir = dir[(base_path.length + 1)..]
+          gitignore.merge!(child_gitignore_path, prefix: relative_dir)
+        end
+
+        begin
+          entries = Dir.children(dir)
+        rescue Errno::EACCES, Errno::ENOENT
+          return
+        end
+
+        entries.sort.each do |name|
+          full = File.join(dir, name)
+          relative = full[(base_path.length + 1)..]
+
+          if File.directory?(full)
+            next if ALWAYS_IGNORED_DIRS.include?(name)
+            if gitignore&.ignored?("#{relative}/") || should_ignore_file?(full, base_path, gitignore)
+              next
+            end
+            _walk_recursive(full, base_path, gitignore, skipped, &block)
+          else
+            if !is_config_file?(full) && should_ignore_file?(full, base_path, gitignore)
+              skipped[:ignored] += 1 if skipped
+              next
+            end
+            yield full
+          end
+        end
+      end
+      private_class_method :_walk_recursive
+
     end
   end
 end

data/lib/clacky/utils/gitignore_parser.rb

@@ -14,6 +14,33 @@ module Clacky
       end
     end
 
+    def merge!(other_gitignore_path, prefix: nil)
+      return unless other_gitignore_path && File.exist?(other_gitignore_path)
+
+      File.readlines(other_gitignore_path, chomp: true).each do |line|
+        next if line.strip.empty? || line.start_with?('#')
+
+        negation = line.start_with?('!')
+        raw = negation ? line[1..] : line
+        info = normalize_pattern(raw)
+
+        if prefix
+          original = info[:pattern]
+          original = original[1..] if info[:is_absolute]
+          info[:pattern] = "#{prefix}/#{original}"
+          info[:is_absolute] = false
+        end
+
+        if negation
+          @negation_patterns << info
+        else
+          @patterns << info
+        end
+      end
+    rescue StandardError => e
+      warn "Warning: Failed to merge .gitignore: #{e.message}"
+    end
+
     # Check if a file path should be ignored
     def ignored?(path)
       relative_path = path.start_with?('./') ? path[2..] : path

data/lib/clacky/version.rb

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