openclacky 0.9.28 → 0.9.30

data/lib/clacky/server/channel/adapters/weixin/adapter.rb

@@ -417,11 +417,11 @@ module Clacky
             r = text.dup
             r.gsub!(/```[^\n]*\n?([\s\S]*?)```/) { Regexp.last_match(1).strip }
             r.gsub!(/!\[[^\]]*\]\([^)]*\)/, "")
-            r.gsub!(/\[([^\]]+)\]\([^)]*\)/, '')
-            r.gsub!(/\*\*([^*]+)\*\*/, '')
-            r.gsub!(/\*([^*]+)\*/, '')
-            r.gsub!(/__([^_]+)__/, '')
-            r.gsub!(/_([^_]+)_/, '')
+            r.gsub!(/\[([^\]]+)\]\([^)]*\)/, '\\1')
+            r.gsub!(/\*\*([^*]+)\*\*/, '\\1')
+            r.gsub!(/\*([^*]+)\*/, '\\1')
+            r.gsub!(/__([^_]+)__/, '\\1')
+            r.gsub!(/_([^_]+)_/, '\\1')
             r.gsub!(/^#+\s+/, "")
             r.gsub!(/^[-*_]{3,}\s*$/, "")
             r.strip

data/lib/clacky/server/http_server.rb

@@ -333,7 +333,13 @@ module Clacky
         # hosts with OPEN_TIMEOUT=8s per attempt × 2 attempts = up to ~16s on the
         # primary alone, before failing over to the fallback domain.  Give them a
         # generous 90s so retry + failover can complete without being cut short.
-        timeout_sec = path.start_with?("/api/brand") ? 90 : 10
+        timeout_sec = if path.start_with?("/api/brand")
+          90
+        elsif path == "/api/tool/browser"
+          30
+        else
+          10
+        end
         Timeout.timeout(timeout_sec) do
           _dispatch_rest(req, res)
         end
@@ -723,6 +729,7 @@ module Clacky
           local_skills = brand.installed_brand_skills.map do |name, meta|
             {
               "name"              => meta["name"] || name,
+              "name_zh"           => meta["name_zh"].to_s,
               # Use locally cached description so it renders correctly offline
               "description"       => meta["description"].to_s,
               "description_zh"    => meta["description_zh"].to_s,
@@ -1385,7 +1392,9 @@ module Clacky
 
           entry = {
             name:              skill.identifier,
+            name_zh:           skill.name_zh,
             description:       skill.context_description,
+            description_zh:    skill.description_zh,
             source:            source,
             enabled:           !skill.disabled?,
             invalid:           skill.invalid?,
@@ -1431,10 +1440,11 @@ module Clacky
         loader      = agent.skill_loader
         loaded_from = loader.loaded_from
 
-        skill_data = skills.map do |skill|
+                  skill_data = skills.map do |skill|
           source_type = loaded_from[skill.identifier]
           {
             name:           skill.identifier,
+            name_zh:        skill.name_zh,
             description:    skill.description || skill.context_description,
             description_zh: skill.description_zh,
             encrypted:      skill.encrypted?,

data/lib/clacky/server/server_master.rb

@@ -42,15 +42,30 @@ module Clacky
       end
 
       def run
-        # 0. Print banner first — before any log output
-        print_banner
-
-        # 1. Kill any existing master on this port before binding.
+        # 0. Kill any existing master on this port before binding.
         kill_existing_master
 
-        # 2. Bind the socket once — master holds it for the entire lifetime.
-        @socket = TCPServer.new(@host, @port)
+        # 1. Try to bind the socket.
+        # If port is 7070 (default), try fallback ports 7071-7075 if occupied.
+        # If port is non-default (user-specified), only try that exact port.
+        original_port = @port
+        max_port = (@port == 7070) ? (@port + 5) : @port
+        @socket = bind_with_fallback(@host, @port, max_port: max_port)
+        
+        if @socket.nil?
+          if @port == 7070
+            Clacky::Logger.error("[Master] No available ports in range 7070-7075")
+          else
+            Clacky::Logger.error("[Master] Port #{@port} is in use")
+          end
+          exit(1)
+        end
+        
         @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+        @port = @socket.local_address.ip_port  # Update to actual bound port
+
+        # 2. Print banner after port is determined
+        print_banner(port_changed: @port != original_port, original_port: original_port)
 
         write_pid_file
 
@@ -221,12 +236,33 @@ module Clacky
         end
       end
 
-      def print_banner
+      # Try to bind to preferred_port, fall back to next ports if occupied.
+      # Returns the bound TCPServer, or nil if all ports in range are occupied.
+      def bind_with_fallback(host, preferred_port, max_port:)
+        (preferred_port..max_port).each do |port|
+          begin
+            server = TCPServer.new(host, port)
+            Clacky::Logger.info("[Master] Bound to port #{port}") if port != preferred_port
+            return server
+          rescue Errno::EADDRINUSE
+            next
+          end
+        end
+        nil
+      end
+
+      def print_banner(port_changed: false, original_port: nil)
         banner = Clacky::Banner.new
         puts ""
         puts banner.colored_cli_logo
         puts banner.colored_tagline
         puts ""
+        
+        if port_changed
+          puts "   [!] Port #{original_port} is in use, using #{@port} instead"
+          puts ""
+        end
+        
         puts "   Web UI: #{banner.highlight("http://#{@host}:#{@port}")}"
         puts "   Version: #{Clacky::VERSION}"
         puts "   Press Ctrl-C to stop."

data/lib/clacky/server/web_ui_controller.rb

@@ -208,13 +208,25 @@ module Clacky
 
       # === Progress ===
 
-      def show_progress(message = nil, prefix_newline: true, output_buffer: nil)
-        @progress_start_time = Time.now
+      def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
+        @progress_start_time = Time.now if phase == "active"
         @live_progress_message = message
         # Reset stdout buffer for each new command so re-subscribe only replays current run
-        @live_stdout_buffer = []
-        emit("progress", message: message, status: "start")
+        @live_stdout_buffer = [] if phase == "active"
+        
+        data = {
+          message: message,
+          progress_type: progress_type,
+          phase: phase,
+          status: phase == "active" ? "start" : "stop"  # backward compat
+        }
+        data[:metadata] = metadata unless metadata.empty?
+        data[:elapsed] = (Time.now - @progress_start_time).round(1) if phase == "done" && @progress_start_time
+        
+        emit("progress", **data)
         forward_to_subscribers { |sub| sub.show_progress(message) }
+        
+        @progress_start_time = nil if phase == "done"
       end
 
       # Stream shell stdout/stderr lines to the browser while a command is running.
@@ -230,14 +242,10 @@ module Clacky
       end
 
       def clear_progress
-        elapsed = @progress_start_time ? (Time.now - @progress_start_time).round(1) : 0
-        @progress_start_time = nil
-        @live_progress_message = nil
         @live_tool_call = nil   # command finished — nothing left to replay
         # Keep @live_stdout_buffer intact — it will be reset on the next show_progress call.
         # This allows a brief replay window even after the command finishes.
-        emit("progress", status: "stop", elapsed: elapsed)
-        forward_to_subscribers { |sub| sub.clear_progress }
+        show_progress(progress_type: "thinking", phase: "done")
       end
 
       # Replay in-progress command state to a newly (re-)subscribing browser tab.

data/lib/clacky/skill.rb

@@ -12,6 +12,7 @@ module Clacky
     # Frontmatter fields that are recognized
     FRONTMATTER_FIELDS = %w[
       name
+      name_zh
       description
       description_zh
       disable-model-invocation
@@ -29,7 +30,7 @@ module Clacky
     ].freeze
 
     attr_reader :directory, :frontmatter, :source_path
-    attr_reader :name, :description, :description_zh, :content
+    attr_reader :name, :description, :name_zh, :description_zh, :content
     attr_reader :disable_model_invocation, :user_invocable
     attr_reader :allowed_tools, :context, :agent_type, :argument_hint, :hooks
     attr_reader :fork_agent, :model, :forbidden_tools, :auto_summarize
@@ -273,6 +274,7 @@ module Clacky
     def to_h
       {
         name: identifier,
+        name_zh: @name_zh,
         description: context_description,
         directory: @directory.to_s,
         source_path: @source_path.to_s,
@@ -386,6 +388,7 @@ module Clacky
       if @cached_metadata
         @frontmatter    = {}
         @name           = @cached_metadata["name"]
+        @name_zh        = @cached_metadata["name_zh"]
         @description    = @cached_metadata["description"]
         @description_zh = @cached_metadata["description_zh"]
         @content        = plain ? plain_file.read.then { |raw| extract_content_only(raw) } : nil
@@ -451,6 +454,7 @@ module Clacky
     # Pull known fields out of @frontmatter into instance variables.
     private def extract_fields_from_frontmatter
       @name           = @frontmatter["name"]
+      @name_zh        = @frontmatter["name_zh"]
       @description    = @frontmatter["description"]
       @description_zh = @frontmatter["description_zh"]
       @disable_model_invocation = @frontmatter["disable-model-invocation"]
@@ -471,7 +475,7 @@ module Clacky
     # the skill is marked @invalid so the UI can display it greyed-out.
     def sanitize_frontmatter
       dir_slug = @directory.basename.to_s
-      valid_slug = ->(s) { s.to_s.match?(/\A[a-z0-9][a-z0-9-]*\z/) }
+      valid_slug = ->(s) { s.to_s.match?(/\A[a-z0-9][a-z0-9_-]*\z/) }
 
       # --- name ---
       # Brand skills loaded via cached_metadata have their name pre-sanitized by

data/lib/clacky/tools/run_project.rb

@@ -113,7 +113,10 @@ module Clacky
         stop_existing_process if @@process_state
 
         begin
-          stdin, stdout, stderr, wait_thr = Open3.popen3(command)
+          # close_others: true prevents inheriting the server's listening socket (port 7070)
+          # when run_project is called from openclacky server. Without this, the spawned
+          # project server may inherit and hold the fd, causing port conflicts.
+          stdin, stdout, stderr, wait_thr = Open3.popen3(command, close_others: true)
 
           @@process_state = {
             stdin: stdin,

data/lib/clacky/tools/shell.rb

@@ -108,7 +108,13 @@ module Clacky
         # acquiring /dev/tty as a controlling terminal, which triggers SIGTTIN
         # when the process is not in the terminal's foreground group.
         # Instead, wrap_with_shell sources the user's rc file explicitly.
-        popen3_opts = { pgroup: 0 }
+        #
+        # close_others: true prevents the child from inheriting file descriptors
+        # other than stdin/stdout/stderr. This is critical when running inside
+        # openclacky server — without it, user commands (rails s, npm run dev, etc.)
+        # inherit the server's listening socket (port 7070), causing port conflicts
+        # when the child process spawns its own server that persists after shell exit.
+        popen3_opts = { pgroup: 0, close_others: true }
         popen3_opts[:chdir] = working_dir if working_dir && Dir.exist?(working_dir)
 
         begin

data/lib/clacky/ui2/ui_controller.rb

@@ -466,8 +466,7 @@ module Clacky
       # Show progress indicator with dynamic elapsed time
       # @param message [String] Progress message (optional, will use random thinking verb if nil)
       # @param prefix_newline [Boolean] Whether to add a blank line before progress (default: true)
-      # @param output_buffer [Hash, nil] Shared output buffer for real-time command output (optional)
-      def show_progress(message = nil, prefix_newline: true, output_buffer: nil)
+      def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
         # Stop any existing progress thread
         stop_progress_thread
 
@@ -476,7 +475,6 @@ module Clacky
 
         @progress_message = message || Clacky::THINKING_VERBS.sample
         @progress_start_time = Time.now
-        @progress_output_buffer = output_buffer
         # Flag used by the progress thread to know when to stop gracefully.
         # Using a flag + join is safe because Thread#kill can interrupt a thread
         # while it holds @render_mutex, causing a permanent deadlock.
@@ -562,7 +560,6 @@ module Clacky
 
         # Signal thread to stop without joining — it will exit on next loop tick
         @progress_start_time = nil
-        @progress_output_buffer = nil
         @stdout_lines = nil
         @progress_thread_stop = true
         # Detach: let the thread die on its own; we do NOT join here
@@ -594,7 +591,6 @@ module Clacky
       # @render_mutex) and leave the mutex permanently locked.
       def stop_progress_thread
         @progress_start_time = nil
-        @progress_output_buffer = nil
         @progress_thread_stop = true
         if @progress_thread&.alive?
           # Join with a short timeout; fall back to kill only as a last resort

data/lib/clacky/ui_interface.rb

@@ -30,7 +30,11 @@ module Clacky
     def log(message, level: :info); end
 
     # === Progress ===
-    def show_progress(message = nil, prefix_newline: true, output_buffer: nil); end
+    # Unified progress indicator with type-based display customization.
+    # progress_type: "thinking" | "retrying" | "idle_compress" | custom
+    # phase: "active" | "done"
+    # metadata: extensible hash (e.g., {attempt: 3, total: 10} for retries)
+    def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {}); end
     def clear_progress; end
 
     # === State updates ===
@@ -39,12 +43,6 @@ module Clacky
     def set_working_status; end
     def set_idle_status; end
 
-    # === Idle compression status ===
-    # Emits a two-phase idle compression status update.
-    # phase: :start  → show "Idle detected. Compressing..." (with spinner)
-    # phase: :end    → update same element with final result (skipped / compressed)
-    def show_idle_status(phase:, message:); end
-
     # === Blocking interaction ===
     def request_confirmation(message, default: true); end
 

data/lib/clacky/utils/arguments_parser.rb

@@ -10,6 +10,16 @@ module Clacky
         # 1. Try standard parsing
         begin
           args = JSON.parse(call[:arguments], symbolize_names: true)
+          
+          # Check if any key contains XML tags (< or >) indicating contamination
+          # Even though JSON.parse succeeded, the keys might be malformed
+          has_xml_contamination = args.keys.any? { |k| k.to_s.include?('<') || k.to_s.include?('>') }
+          
+          if has_xml_contamination
+            # Force repair even though JSON.parse succeeded
+            raise JSON::ParserError.new("Keys contain XML contamination")
+          end
+          
           return validate_required_params(call, args, tool_registry)
         rescue JSON::ParserError => e
           # Continue to repair
@@ -30,24 +40,31 @@ module Clacky
 
       # Simple JSON repair: complete brackets and quotes, and remove XML contamination
       def self.repair_json(json_str)
-        result = json_str.strip
 
+        result = json_str.strip
+        # Step 0: Convert literal \n (backslash+n) to real newlines
+        result = result.gsub(/\\n/, "\n")
+        # Step 0.5: Unescape quotes in JSON keys and values (\" -> ")
+        # This handles cases like {"end_line\":550 or name=\"path\"
+        result = result.gsub(/\\"/, '"')
         # Step 1: Remove XML-style parameter tags that Claude might mix in
         # Pattern 1: </parameter> closing tags - remove completely
         result = result.gsub(/<\/parameter>/, '')
-        
+
         # Pattern 2: <parameter name="key"> or <parameter name="key": opening tags -> convert to JSON key
         # Example: \n<parameter name="end_line"> 330 -> , "end_line": 330
         # Also handles: \n<parameter name="end_line": 330 -> , "end_line": 330
-        result = result.gsub(/<parameter\s+name="([^"]+)":\s*/) { |match| ", \"#{$1}\": " }
-        result = result.gsub(/<parameter\s+name="([^"]+)">/) { |match| ", \"#{$1}\":" }
-        
+        # result = result.gsub(/<parameter\s+name="([^"\\]+)":\s*/) { |match| ", \"#{$1}\": " }
+        # result = result.gsub(/<parameter\s+name="([^"\\]+)">/) { |match| ", \"#{$1}\":" }
+        result = result.gsub(/<parameter\s+name=\\?"([^"\\]+)\\?"[>:]?\s*/) { |match| ", \"#{$1}\": " }
+
         # Pattern 3: Remove any remaining XML-like tags
         result = result.gsub(/<[^>]+>/, '')
 
         # Step 2: Clean up newlines with commas
         # Example: 315\n, "end_line" -> 315, "end_line"
         result = result.gsub(/\n\s*,/, ',')
+        result = result.gsub(/\n,/, ',')
         result = result.gsub(/,\s*\n/, ',')
 
         # Step 3: Clean up formatting issues

data/lib/clacky/version.rb

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

data/lib/clacky/web/app.css

@@ -793,13 +793,23 @@ body {
 .session-item .session-name {
   flex: 1;
   min-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  display: flex;
+  align-items: center;
+  gap: 4px;
   color: var(--color-text-secondary);
   font-weight: 500;
   transition: color .2s ease, font-weight .2s ease;
 }
+.session-item .session-name .session-name__text {
+  flex: 1;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.session-item .session-name .session-badge {
+  flex-shrink: 0;
+}
 /* Hover: subtle background overlay */
 .session-item:hover {
   background: var(--color-bg-hover);
@@ -863,8 +873,6 @@ body {
 .session-name {
   font-size: 12px;
   white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
 }
 /* While renaming, lift overflow so the input is fully visible */
 .session-name.renaming {
@@ -2004,6 +2012,14 @@ body {
   padding: 4px 0;
 }
 
+.skill-ac-empty {
+  padding: 14px 16px;
+  font-size: 13px;
+  color: var(--color-text-tertiary, #888);
+  text-align: left;
+  font-style: italic;
+}
+
 .skill-ac-item {
   display: flex;
   align-items: baseline;
@@ -2040,6 +2056,30 @@ body {
   color: var(--color-accent-primary);
   white-space: nowrap;
   flex-shrink: 0;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.skill-ac-name-zh {
+  font-family: inherit;
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--color-accent-primary);
+}
+
+.skill-ac-name-id {
+  font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, monospace;
+  font-size: 11px;
+  font-weight: 400;
+  color: var(--color-text-secondary);
+  opacity: 0.7;
+}
+
+.skill-ac-highlight {
+  background: rgba(255, 200, 0, 0.35);
+  color: inherit;
+  font-weight: inherit;
 }
 
 .skill-ac-desc {