openclacky 1.2.5 → 1.2.7

data/lib/clacky/billing/billing_store.rb

@@ -74,10 +74,11 @@ module Clacky
 
       # Get summary statistics for a time period
       # @param period [Symbol] :day, :week, :month, :year, or :all
+      # @param model [String, nil] Filter by model name
       # @return [Hash] Summary with total_cost, total_tokens, by_model, etc.
-      def summary(period: :month)
+      def summary(period: :month, model: nil)
         from_time = period_start(period)
-        records = query(from: from_time)
+        records = query(from: from_time, model: model)
 
         total_cost = records.sum { |r| r.cost_usd || 0 }
         total_prompt = records.sum { |r| r.prompt_tokens || 0 }
@@ -116,10 +117,11 @@ module Clacky
 
       # Get daily cost breakdown for the last N days
       # @param days [Integer] Number of days to include
+      # @param model [String, nil] Filter by model name
       # @return [Array<Hash>] Daily summaries with date and cost
-      def daily_breakdown(days: 30)
+      def daily_breakdown(days: 30, model: nil)
         from_time = Time.now - (days * 24 * 60 * 60)
-        records = query(from: from_time)
+        records = query(from: from_time, model: model)
 
         by_day = records.group_by { |r| r.timestamp.strftime("%Y-%m-%d") }
 
@@ -159,6 +161,62 @@ module Clacky
         deleted
       end
 
+      # Clear billing records
+      # @param scope [Symbol] :today or :all
+      # @return [Integer] Number of records/files deleted
+      def clear(scope: :today)
+        case scope
+        when :today
+          clear_today
+        when :all
+          clear_all
+        else
+          0
+        end
+      end
+
+      private def clear_today
+        # Remove today's records from the current month file
+        month_file = current_month_file
+        return 0 unless File.exist?(month_file)
+
+        today_start = Time.new(Time.now.year, Time.now.month, Time.now.day)
+        kept_lines = []
+        deleted_count = 0
+
+        File.foreach(month_file) do |line|
+          next if line.strip.empty?
+
+          begin
+            hash = JSON.parse(line, symbolize_names: true)
+            record_time = Time.parse(hash[:timestamp].to_s) rescue nil
+
+            if record_time && record_time >= today_start
+              deleted_count += 1
+            else
+              kept_lines << line
+            end
+          rescue JSON::ParserError
+            kept_lines << line
+          end
+        end
+
+        # Rewrite the file without today's records
+        File.open(month_file, "w") do |f|
+          kept_lines.each { |line| f.print(line) }
+        end
+        FileUtils.chmod(0o600, month_file) if File.exist?(month_file)
+
+        deleted_count
+      end
+
+      private def clear_all
+        # Delete all billing files
+        files = billing_files
+        files.each { |f| File.delete(f) }
+        files.size
+      end
+
       private def ensure_billing_dir
         FileUtils.mkdir_p(@billing_dir) unless Dir.exist?(@billing_dir)
       end

data/lib/clacky/brand_config.rb

@@ -737,6 +737,9 @@ module Clacky
       dl = platform_client.download_file(url, tmp_zip)
       raise dl[:error].to_s unless dl[:success]
 
+      zip_size = File.size?(tmp_zip).to_i
+      raise "Empty ZIP downloaded for #{slug}" if zip_size < 22  # min valid zip = empty central directory
+
       # Extract into dest_dir (overwrite existing files).
       # Auto-detect whether the zip has a single root folder to strip.
       # Uses get_input_stream instead of entry.extract to avoid rubyzip 3.x
@@ -787,6 +790,8 @@ module Clacky
 
       { success: true, name: slug, version: version }
     rescue StandardError, ScriptError => e
+      FileUtils.rm_f(tmp_zip) if defined?(tmp_zip) && tmp_zip
+      FileUtils.rm_rf(dest_dir) if defined?(dest_dir) && dest_dir
       { success: false, error: e.message }
     end
 

data/lib/clacky/cli.rb

@@ -403,6 +403,23 @@ module Clacky
         agent.rename(auto_name)
       end
 
+      # Format error message and backtrace (first 3 lines) for session saving
+      private def format_error(e)
+        "#{e.message}\n#{e.backtrace&.first(3)&.join("\n")}"
+      end
+
+      # Validates non-interactive file paths and maps them to hashes with detected MIME types
+      private def prepare_non_interactive_files(file_paths)
+        file_paths.each do |path|
+          raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
+        end
+        # Convert file paths to file hashes — agent.run decides how to handle each
+        file_paths.map do |path|
+          mime = Utils::FileProcessor.detect_mime_type(path) rescue "application/octet-stream"
+          { name: File.basename(path), mime_type: mime, path: path }
+        end
+      end
+
       def validate_working_directory(path, config = nil)
         working_dir = path || Dir.pwd
 
@@ -540,9 +557,10 @@ module Clacky
           session_manager&.save(agent.to_session_data(status: :interrupted))
           ui_controller.show_warning("Task interrupted by user")
         else
-          error_message = "#{exception.message}\n#{exception.backtrace&.first(3)&.join("\n")}"
+          error_message = format_error(exception)
           session_manager&.save(agent.to_session_data(status: :error, error_message: error_message))
-          ui_controller.show_error("Error: #{exception.message}")
+          code = exception.is_a?(Clacky::InsufficientCreditError) ? exception.error_code : nil
+          ui_controller.show_error("Error: #{exception.message}", code: code)
         end
       end
 
@@ -553,31 +571,61 @@ module Clacky
         # Force auto-approve — no one is around to confirm anything
         agent_config.permission_mode = :auto_approve
 
-        # Validate paths up-front so we fail fast with a clear message
-        file_paths.each do |path|
-          raise ArgumentError, "File not found: #{path}" unless File.exist?(path)
-        end
+        is_json = !!options[:json]
 
-        # Convert file paths to file hashes — agent.run decides how to handle each
-        files = file_paths.map do |path|
-          mime = Utils::FileProcessor.detect_mime_type(path) rescue "application/octet-stream"
-          { name: File.basename(path), mime_type: mime, path: path }
+        # Validate and prepare files up-front (DRY)
+        begin
+          files = prepare_non_interactive_files(file_paths)
+        rescue => e
+          session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+
+          if is_json
+            ui = Clacky::JsonUIController.new
+            ui.emit("error", message: e.message)
+            ui.set_idle_status
+          else
+            $stderr.puts "Error: #{e.message}"
+          end
+          exit(1)
         end
 
-        # Wire up plain-text stdout UI so all agent output is visible
-        plain_ui = Clacky::PlainUIController.new
-        agent.instance_variable_set(:@ui, plain_ui)
 
-        auto_name_session(agent, message)
-        agent.run(message, files: files)
-        session_manager&.save(agent.to_session_data(status: :success))
-        exit(0)
-      rescue Clacky::AgentInterrupted
-        $stderr.puts "\nInterrupted."
-        exit(1)
-      rescue => e
-        $stderr.puts "Error: #{e.message}"
-        exit(1)
+        # Wire up the appropriate UI controller and execute
+        if is_json
+          ui = Clacky::JsonUIController.new
+          agent.instance_variable_set(:@ui, ui)
+          ui.emit("system", message: "Agent started", model: agent_config.model_name, working_dir: agent.working_dir)
+
+          status = run_json_task(agent, ui, session_manager) do
+            auto_name_session(agent, message)
+            agent.run(message, files: files)
+          end
+
+          if status == :success
+            ui.emit("done", total_cost: agent.total_cost, total_tasks: agent.total_tasks)
+            exit(0)
+          else
+            exit(1)
+          end
+        else
+          ui = Clacky::PlainUIController.new
+          agent.instance_variable_set(:@ui, ui)
+
+          begin
+            auto_name_session(agent, message)
+            agent.run(message, files: files)
+            session_manager&.save(agent.to_session_data(status: :success))
+            exit(0)
+          rescue Clacky::AgentInterrupted
+            session_manager&.save(agent.to_session_data(status: :interrupted))
+            $stderr.puts "\nInterrupted."
+            exit(1)
+          rescue => e
+            session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
+            $stderr.puts "Error: #{e.message}"
+            exit(1)
+          end
+        end
       end
 
       # Run agent with JSON (NDJSON) output mode — persistent process.
@@ -620,6 +668,7 @@ module Clacky
               next
             end
 
+
             # Handle built-in commands
             case content.downcase
             when "/exit", "/quit"
@@ -658,12 +707,15 @@ module Clacky
         yield
         session_manager&.save(agent.to_session_data(status: :success))
         json_ui.update_sessionbar(tasks: agent.total_tasks, cost: agent.total_cost)
+        :success
       rescue Clacky::AgentInterrupted
         session_manager&.save(agent.to_session_data(status: :interrupted))
         json_ui.emit("interrupted")
+        :interrupted
       rescue => e
-        session_manager&.save(agent.to_session_data(status: :error, error_message: e.message))
+        session_manager&.save(agent.to_session_data(status: :error, error_message: format_error(e)))
         json_ui.emit("error", message: e.message)
+        :error
       ensure
         json_ui.set_idle_status
       end

data/lib/clacky/client.rb

@@ -301,7 +301,12 @@ module Clacky
         end
       end
 
-      raise_error(response) unless response.status == 200
+      unless response.status == 200
+        recovered_body = response.body.to_s
+        recovered_body = sse_buf.to_s if recovered_body.empty?
+        recovered = Struct.new(:status, :body).new(response.status, recovered_body)
+        raise_error(recovered)
+      end
       MessageFormat::Anthropic.parse_response(aggregator.to_h)
     end
 
@@ -351,7 +356,10 @@ module Clacky
         end
       end
 
-      raise_error(response) unless response.status == 200
+      unless response.status == 200
+        response.env.body = sse_buf if response.body.to_s.empty?
+        raise_error(response)
+      end
       MessageFormat::OpenAI.parse_response(aggregator.to_h)
     end
 
@@ -533,6 +541,22 @@ module Clacky
     def raise_error(response)
       error_body    = JSON.parse(response.body) rescue nil
       error_message = extract_error_message(error_body, response.body)
+      error_code    = extract_error_code(error_body)
+
+      Clacky::Logger.warn("client.raise_error",
+        status: response.status,
+        body: response.body.to_s[0, 2000],
+        error_message: error_message.to_s[0, 500],
+        error_code: error_code
+      )
+
+      if error_code == "insufficient_credit" || response.status == 402
+        raise InsufficientCreditError.new(
+          "[LLM] Insufficient credit: #{error_message}",
+          error_code: "insufficient_credit",
+          provider_id: @provider_id
+        )
+      end
 
       case response.status
       when 400
@@ -548,7 +572,6 @@ module Clacky
         # broken message is not replayed on the next user turn.
         raise BadRequestError, "[LLM] Client request error: #{error_message}"
       when 401 then raise AgentError, "[LLM] Invalid API key"
-      when 402 then raise AgentError, "[LLM] Billing or payment issue (possibly out of credits): #{error_message}"
       when 403 then raise AgentError, "[LLM] Access denied: #{error_message}"
       when 404 then raise AgentError, "[LLM] API endpoint not found: #{error_message}"
       when 429 then raise RetryableError, "[LLM] Rate limit exceeded, please wait a moment"
@@ -565,19 +588,51 @@ module Clacky
       end
     end
 
+    private def extract_error_code(error_body)
+      return nil unless error_body.is_a?(Hash)
+      err = error_body["error"]
+      return err["code"] if err.is_a?(Hash) && err["code"].is_a?(String)
+      nil
+    end
+
     def extract_error_message(error_body, raw_body)
       if raw_body.is_a?(String) && raw_body.strip.start_with?("<!DOCTYPE", "<html")
         return "Invalid API endpoint or server error (received HTML instead of JSON)"
       end
 
+      return "(empty response body)" if raw_body.to_s.strip.empty? && !error_body.is_a?(Hash)
       return raw_body unless error_body.is_a?(Hash)
 
       error_body["upstreamMessage"]&.then { |m| return m unless m.empty? }
-      error_body.dig("error", "message")&.then { |m| return m } if error_body["error"].is_a?(Hash)
+
+      if error_body["error"].is_a?(Hash)
+        upstream_msg = extract_upstream_error(error_body["error"])
+        return upstream_msg if upstream_msg
+      end
+
       error_body["message"]&.then             { |m| return m }
       error_body["error"].is_a?(String) ? error_body["error"] : (raw_body.to_s[0..200] + (raw_body.to_s.length > 200 ? "..." : ""))
     end
 
+    # OpenRouter nests the real provider error inside metadata.raw as a JSON string.
+    private def extract_upstream_error(error_hash)
+      raw = error_hash.dig("metadata", "raw")
+      if raw.is_a?(String) && !raw.empty?
+        nested = JSON.parse(raw) rescue nil
+        if nested.is_a?(Hash)
+          details = nested.dig("error", "details")
+          if details.is_a?(String) && !details.empty?
+            innermost = JSON.parse(details) rescue nil
+            if innermost.is_a?(Hash) && innermost.dig("error", "message")
+              return innermost.dig("error", "message")
+            end
+          end
+          return nested.dig("error", "message") if nested.dig("error", "message")
+        end
+      end
+      error_hash["message"]
+    end
+
     # Parse JSON with user-friendly error messages.
     # @param json_string [String] the JSON string to parse
     # @param context [String] a description of what's being parsed (e.g., "LLM response")

data/lib/clacky/default_parsers/wps_parser.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# Clacky WPS Parser — CLI interface
+#
+# Handles WPS Office formats:
+#   .wps — WPS Writer (word processor)
+#   .et  — WPS Spreadsheet
+#   .dps — WPS Presentation
+#
+# Usage:
+#   ruby wps_parser.rb <file_path>
+#
+# Output:
+#   stdout — extracted text content (UTF-8)
+#   stderr — error messages
+#   exit 0 — success
+#   exit 1 — failure
+#
+# VERSION: 1
+
+require "open3"
+require "tmpdir"
+require "fileutils"
+
+MIN_CONTENT_BYTES = 20
+
+# Convert WPS formats to text using LibreOffice headless mode.
+# .et (spreadsheet) → csv for structured output; .wps/.dps → txt.
+def try_libreoffice(path, ext)
+  Dir.mktmpdir("clacky-wps") do |dir|
+    output_ext = ext == ".et" ? "csv" : "txt"
+    _stdout, _stderr, status = Open3.capture3(
+      "libreoffice", "--headless", "--convert-to", output_ext,
+      "--outdir", dir, path
+    )
+    return nil unless status.success?
+
+    output_file = Dir.glob(File.join(dir, "*.#{output_ext}")).first
+    return nil unless output_file && File.exist?(output_file)
+
+    text = File.read(output_file).strip
+    return nil if text.bytesize < MIN_CONTENT_BYTES
+    text
+  end
+rescue Errno::ENOENT
+  nil
+end
+
+# --- main ---
+
+path = ARGV[0]
+
+if path.nil? || path.empty?
+  warn "Usage: ruby wps_parser.rb <file_path>"
+  exit 1
+end
+
+unless File.exist?(path)
+  warn "File not found: #{path}"
+  exit 1
+end
+
+ext = File.extname(path).downcase
+
+unless %w[.wps .et .dps].include?(ext)
+  warn "Unsupported WPS format: #{ext}"
+  exit 1
+end
+
+text = try_libreoffice(path, ext)
+
+if text
+  print text
+  exit 0
+else
+  warn "Could not extract text from #{ext} file."
+  warn "Tip: install LibreOffice to enable WPS format support."
+  warn "  macOS:  brew install --cask libreoffice"
+  warn "  Linux:  apt install libreoffice"
+  exit 1
+end

data/lib/clacky/default_skills/onboard/SKILL.md

@@ -216,8 +216,8 @@ Silently run `ruby "SKILL_DIR/scripts/install_builtin_skills.rb"`,
 then parse the last stdout line as JSON and read `installed` as N.
 
 - If N > 0, show one line:
-  - zh: `✅ 已为你内置 N 个技能，输入 /skills 随时查看。`
-  - en: `✅ Installed N builtin skills. Type /skills anytime to view them.`
+  - zh: `✅ 已为你内置 N 个技能。`
+  - en: `✅ Installed N builtin skills.`
 
 ### A.10. Import external skills (optional)
 

data/lib/clacky/json_ui_controller.rb

@@ -101,8 +101,11 @@ module Clacky
       emit("warning", message: message)
     end
 
-    def show_error(message)
-      emit("error", message: message)
+    def show_error(message, code: nil, top_up_url: nil)
+      payload = { message: message }
+      payload[:code] = code if code
+      payload[:top_up_url] = top_up_url if top_up_url
+      emit("error", **payload)
     end
 
     def show_success(message)

data/lib/clacky/message_format/anthropic.rb

@@ -39,6 +39,17 @@ module Clacky
         msg[:content].select { |b| b[:type] == "tool_result" }.map { |b| b[:tool_use_id] }
       end
 
+      # Anthropic requires tool_use.id to match ^[a-zA-Z0-9_-]+$ (max 128 chars).
+      # Some OpenAI-compatible upstreams (e.g. kimi-k2.6) return ids like "tool_name:0"
+      # — fine for OpenAI, rejected by Anthropic. We replace illegal chars with "_"
+      # at the format boundary so ids stay self-consistent across use/result pairs
+      # (pure function → same input maps to same output in both directions).
+      def sanitize_tool_use_id(id)
+        s = id.to_s
+        s = s.gsub(/[^a-zA-Z0-9_-]/, "_")
+        s.length > 128 ? s[0, 128] : s
+      end
+
       # ── Request building ──────────────────────────────────────────────────────
 
       # Convert canonical @messages + tools into an Anthropic API request body.
@@ -156,7 +167,6 @@ module Clacky
       end
 
       # ── Tool result formatting ────────────────────────────────────────────────
-
       # Format tool results into canonical messages to append to @messages.
       # Input:  response (canonical, has :tool_calls), tool_results array
       # Output: canonical messages: [{ role: "tool", tool_call_id:, content: }]
@@ -211,7 +221,7 @@ module Clacky
               else
                 raw_args
               end
-            blocks << { type: "tool_use", id: tc[:id], name: name, input: input || {} }
+            blocks << { type: "tool_use", id: sanitize_tool_use_id(tc[:id]), name: name, input: input || {} }
           end
 
           return { role: "assistant", content: blocks }
@@ -250,7 +260,7 @@ module Clacky
                          else
                            raw_content
                          end
-          block = { type: "tool_result", tool_use_id: msg[:tool_call_id], content: tool_content }
+          block = { type: "tool_result", tool_use_id: sanitize_tool_use_id(msg[:tool_call_id]), content: tool_content }
           block[:cache_control] = hoisted_cache_control if hoisted_cache_control
           return { role: "user", content: [block] }
         end

data/lib/clacky/message_format/bedrock.rb

@@ -187,7 +187,7 @@ module Clacky
             name  = func[:name]  || tc[:name]
             raw_args = func[:arguments] || tc[:arguments]
             input = raw_args.is_a?(String) ? (JSON.parse(raw_args) rescue {}) : (raw_args || {})
-            blocks << { toolUse: { toolUseId: tc[:id], name: name, input: input } }
+            blocks << { toolUse: { toolUseId: Anthropic.sanitize_tool_use_id(tc[:id]), name: name, input: input } }
           end
 
           return { role: "assistant", content: blocks }
@@ -208,7 +208,7 @@ module Clacky
                          end
           return {
             role: "user",
-            content: [{ toolResult: { toolUseId: msg[:tool_call_id], content: result_blocks } }]
+            content: [{ toolResult: { toolUseId: Anthropic.sanitize_tool_use_id(msg[:tool_call_id]), content: result_blocks } }]
           }
         end
 

data/lib/clacky/plain_ui_controller.rb

@@ -117,7 +117,7 @@ module Clacky
       puts_line("[warn] #{message}")
     end
 
-    def show_error(message)
+    def show_error(message, code: nil, top_up_url: nil)
       puts_line("[error] #{message}")
     end
 

data/lib/clacky/platform_http_client.rb

@@ -228,12 +228,17 @@ module Clacky
           h.request(req) do |resp|
             case resp.code.to_i
             when 200
+              expected_len = resp["content-length"]&.to_i
               File.open(dest, "wb") do |f|
                 resp.read_body do |chunk|
                   f.write(chunk)
                   written += chunk.bytesize
                 end
               end
+              if expected_len && expected_len > 0 && written != expected_len
+                raise RetryableNetworkError,
+                      "Truncated download: got #{written} bytes, expected #{expected_len}"
+              end
             when 301, 302, 303, 307, 308
               location = resp["location"]
               raise RetryableNetworkError, "Redirect with no Location header" if location.nil? || location.empty?
@@ -354,13 +359,35 @@ module Clacky
         { success: true, data: body["data"] || body }
       else
         error_code = body["code"]
+        server_msg = extract_server_error_message(body)
         error_msg  = API_ERROR_MESSAGES[error_code] ||
-                     body["error"] ||
+                     server_msg ||
                      "Request failed (HTTP #{code}#{error_code ? ", code: #{error_code}" : ""}). Please contact support."
         { success: false, error: error_msg, data: body }
       end
     end
 
+    # Server error messages can come back under different keys / shapes:
+    #   { "error":  "msg" }           — single string
+    #   { "errors": ["msg1", "msg2"] } — array of strings (Rails .errors.full_messages)
+    #   { "errors": "msg" }            — string (less common)
+    #   { "message": "msg" }           — alternative key
+    # Returns the first non-blank human-readable string, or nil if none.
+    private def extract_server_error_message(body)
+      return nil unless body.is_a?(Hash)
+
+      [body["error"], body["errors"], body["message"]].each do |val|
+        case val
+        when String
+          return val unless val.strip.empty?
+        when Array
+          joined = val.compact.map(&:to_s).reject(&:empty?).join("; ")
+          return joined unless joined.empty?
+        end
+      end
+      nil
+    end
+
     # Raised for transient failures that should be retried (timeouts, conn resets, SSL errors).
     class RetryableNetworkError < StandardError; end
   end