openclacky 1.1.5 → 1.2.0

data/lib/clacky/billing/billing_store.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "securerandom"
+require_relative "billing_record"
+
+module Clacky
+  module Billing
+    # Persistent storage for billing records using JSONL files
+    # Records are stored in monthly files: ~/.clacky/billing/YYYY-MM.jsonl
+    class BillingStore
+      BILLING_DIR = File.join(Dir.home, ".clacky", "billing")
+
+      def initialize(billing_dir: nil)
+        @billing_dir = billing_dir || BILLING_DIR
+        ensure_billing_dir
+      end
+
+      # Append a billing record to the current month's file
+      # @param record [BillingRecord] The record to append
+      # @return [String] The record ID
+      def append(record)
+        record.id ||= SecureRandom.uuid
+        record.timestamp ||= Time.now
+
+        month_file = current_month_file
+        File.open(month_file, "a") do |f|
+          f.puts(JSON.generate(record.to_h))
+        end
+        FileUtils.chmod(0o600, month_file)
+
+        record.id
+      end
+
+      # Query billing records with optional filters
+      # @param from [Time, nil] Start time (inclusive)
+      # @param to [Time, nil] End time (inclusive)
+      # @param model [String, nil] Filter by model name
+      # @param session_id [String, nil] Filter by session ID
+      # @param limit [Integer, nil] Maximum number of records to return
+      # @return [Array<BillingRecord>] Matching records, newest first
+      def query(from: nil, to: nil, model: nil, session_id: nil, limit: nil)
+        records = []
+
+        billing_files.each do |file|
+          File.foreach(file) do |line|
+            next if line.strip.empty?
+
+            begin
+              hash = JSON.parse(line, symbolize_names: true)
+              record = BillingRecord.from_h(hash)
+
+              # Apply filters
+              next if from && record.timestamp < from
+              next if to && record.timestamp > to
+              next if model && record.model != model
+              next if session_id && record.session_id != session_id
+
+              records << record
+            rescue JSON::ParserError
+              # Skip malformed lines
+              next
+            end
+          end
+        end
+
+        # Sort by timestamp descending (newest first)
+        records.sort_by! { |r| r.timestamp }.reverse!
+
+        # Apply limit
+        limit ? records.first(limit) : records
+      end
+
+      # Get summary statistics for a time period
+      # @param period [Symbol] :day, :week, :month, :year, or :all
+      # @return [Hash] Summary with total_cost, total_tokens, by_model, etc.
+      def summary(period: :month)
+        from_time = period_start(period)
+        records = query(from: from_time)
+
+        total_cost = records.sum { |r| r.cost_usd || 0 }
+        total_prompt = records.sum { |r| r.prompt_tokens || 0 }
+        total_completion = records.sum { |r| r.completion_tokens || 0 }
+        total_cache_read = records.sum { |r| r.cache_read_tokens || 0 }
+        total_cache_write = records.sum { |r| r.cache_write_tokens || 0 }
+
+        by_model = records.group_by(&:model).transform_values do |rs|
+          {
+            cost: rs.sum { |r| r.cost_usd || 0 },
+            prompt_tokens: rs.sum { |r| r.prompt_tokens || 0 },
+            completion_tokens: rs.sum { |r| r.completion_tokens || 0 },
+            requests: rs.size
+          }
+        end
+
+        by_day = records.group_by { |r| r.timestamp.strftime("%Y-%m-%d") }.transform_values do |rs|
+          rs.sum { |r| r.cost_usd || 0 }
+        end
+
+        {
+          period: period,
+          from: from_time&.iso8601,
+          to: Time.now.iso8601,
+          total_cost: total_cost.round(6),
+          total_tokens: total_prompt + total_completion,
+          prompt_tokens: total_prompt,
+          completion_tokens: total_completion,
+          cache_read_tokens: total_cache_read,
+          cache_write_tokens: total_cache_write,
+          by_model: by_model,
+          by_day: by_day,
+          record_count: records.size
+        }
+      end
+
+      # Get daily cost breakdown for the last N days
+      # @param days [Integer] Number of days to include
+      # @return [Array<Hash>] Daily summaries with date and cost
+      def daily_breakdown(days: 30)
+        from_time = Time.now - (days * 24 * 60 * 60)
+        records = query(from: from_time)
+
+        by_day = records.group_by { |r| r.timestamp.strftime("%Y-%m-%d") }
+
+        (0...days).map do |i|
+          date = (Time.now - (i * 24 * 60 * 60)).strftime("%Y-%m-%d")
+          day_records = by_day[date] || []
+          {
+            date: date,
+            cost: day_records.sum { |r| r.cost_usd || 0 }.round(6),
+            tokens: day_records.sum { |r| r.total_tokens },
+            prompt_tokens: day_records.sum { |r| r.prompt_tokens || 0 },
+            completion_tokens: day_records.sum { |r| r.completion_tokens || 0 },
+            cache_read_tokens: day_records.sum { |r| r.cache_read_tokens || 0 },
+            cache_write_tokens: day_records.sum { |r| r.cache_write_tokens || 0 },
+            requests: day_records.size
+          }
+        end.reverse
+      end
+
+      # Delete old billing records
+      # @param before [Time] Delete records before this time
+      # @return [Integer] Number of files deleted
+      def cleanup(before:)
+        deleted = 0
+        billing_files.each do |file|
+          # Parse month from filename (YYYY-MM.jsonl)
+          basename = File.basename(file, ".jsonl")
+          file_month = Time.parse("#{basename}-01") rescue nil
+          next unless file_month
+
+          # Delete if the entire month is before the cutoff
+          if file_month < before - (31 * 24 * 60 * 60)
+            File.delete(file)
+            deleted += 1
+          end
+        end
+        deleted
+      end
+
+      private def ensure_billing_dir
+        FileUtils.mkdir_p(@billing_dir) unless Dir.exist?(@billing_dir)
+      end
+
+      private def current_month_file
+        File.join(@billing_dir, "#{Time.now.strftime('%Y-%m')}.jsonl")
+      end
+
+      private def billing_files
+        Dir.glob(File.join(@billing_dir, "*.jsonl")).sort.reverse
+      end
+
+      private def period_start(period)
+        now = Time.now
+        case period
+        when :day
+          Time.new(now.year, now.month, now.day)
+        when :week
+          now - (7 * 24 * 60 * 60)
+        when :month
+          Time.new(now.year, now.month, 1)
+        when :year
+          Time.new(now.year, 1, 1)
+        when :all
+          nil
+        else
+          Time.new(now.year, now.month, 1)
+        end
+      end
+    end
+  end
+end

data/lib/clacky/cli.rb

@@ -101,7 +101,7 @@ module Clacky
       end
 
       # Validate and get working directory
-      working_dir = validate_working_directory(options[:path])
+      working_dir = validate_working_directory(options[:path], agent_config)
 
       # Update agent config with CLI options
       agent_config.permission_mode = options[:mode].to_sym if options[:mode]
@@ -338,25 +338,16 @@ module Clacky
 
       # ── Brand license check (CLI mode) ──────────────────────────────────────
       #
-      # Called at the start of run_agent_with_ui2, before UI2 raw mode begins.
-      # Uses Thor's say + tty-prompt for interaction (both are existing dependencies).
-      #
-      # Flow:
-      #   not branded       -> skip (standard OpenClacky experience)
-      #   branded, no key   -> prompt for license key and activate
-      #   branded, expired  -> warn and continue
-      #   branded, active   -> send heartbeat if interval elapsed (once per day)
+      # CLI is a developer-oriented entrypoint: we never block startup with an
+      # interactive license prompt. Unactivated installs run in free mode; the
+      # WebUI is where end-users activate. This method only surfaces non-blocking
+      # warnings (expiry, offline grace period) and dispatches async heartbeats.
       private def check_brand_license_cli
         brand = Clacky::BrandConfig.load
         return unless brand.branded?
+        return unless brand.activated?
 
-        Clacky::Logger.info("[Brand] check_brand_license_cli: activated=#{brand.activated?} expired=#{brand.expired?} expires_at=#{brand.license_expires_at&.iso8601 || "nil"} last_heartbeat=#{brand.license_last_heartbeat&.iso8601 || "nil"}")
-
-        unless brand.activated?
-          Clacky::Logger.info("[Brand] check_brand_license_cli: not activated, prompting user")
-          cli_prompt_license_activation(brand)
-          return
-        end
+        Clacky::Logger.info("[Brand] check_brand_license_cli: activated=true expired=#{brand.expired?} expires_at=#{brand.license_expires_at&.iso8601 || "nil"} last_heartbeat=#{brand.license_last_heartbeat&.iso8601 || "nil"}")
 
         if brand.expired?
           Clacky::Logger.warn("[Brand] check_brand_license_cli: license expired at #{brand.license_expires_at&.iso8601}")
@@ -366,11 +357,6 @@ module Clacky
           return
         end
 
-        # Heartbeat is fire-and-forget — startup must never block on the
-        # license server. The grace_period_exceeded? check below now keys off
-        # license_last_heartbeat_failure (set on a failed heartbeat, cleared
-        # on success), so a user who simply hasn't run the app for >3 days
-        # no longer sees a false "offline" warning on first launch.
         if brand.heartbeat_due?
           Clacky::Logger.info("[Brand] check_brand_license_cli: heartbeat due, dispatching async...")
           Thread.new do
@@ -397,46 +383,16 @@ module Clacky
         end
       end
 
-      # Interactive license key prompt using tty-prompt.
-      private def cli_prompt_license_activation(brand)
-        prompt = TTY::Prompt.new
-
-        say ""
-        say "Welcome to #{brand.product_name}!", :cyan
-        say "A license key is required to activate this installation."
-        say ""
-
-        loop do
-          key = prompt.ask("Enter your license key (XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX):",
-                           required: false) { |q| q.modify :strip }
-
-          if key.nil? || key.empty?
-            say "No key entered. You can activate later by re-launching.", :yellow
-            say ""
-            return
-          end
-
-          unless key.match?(/\A[0-9A-Fa-f]{8}(-[0-9A-Fa-f]{8}){4}\z/)
-            say "Invalid key format. Expected: XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX", :red
-            next
-          end
-
-          say "Activating..."
-          result = brand.activate!(key)
+      CLI_DEFAULT_SESSION_NAME = "CLI Session"
 
-          if result[:success]
-            say result[:message], :green
-            say ""
-            return
-          else
-            say result[:message], :red
-            say "(Press Enter to skip activation.)"
-          end
-        end
+      # Format a number with thousand separators for display
+      # @param num [Integer, Float] The number to format
+      # @return [String] Formatted number string
+      private def format_number(num)
+        return "0" if num.nil? || num == 0
+        num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
       end
 
-      CLI_DEFAULT_SESSION_NAME = "CLI Session"
-
       # Auto-name a CLI session from the first user message, mirroring server-side logic.
       # Renames when the agent has no history yet (i.e. first message of the session).
       private def auto_name_session(agent, input)
@@ -447,12 +403,14 @@ module Clacky
         agent.rename(auto_name)
       end
 
-      def validate_working_directory(path)
+      def validate_working_directory(path, config = nil)
         working_dir = path || Dir.pwd
 
-        # If no path specified and currently in home directory, use ~/clacky_workspace
+        # If no path specified and currently in home directory, use configured
+        # default_working_dir (or ~/clacky_workspace as fallback)
         if path.nil? && File.expand_path(working_dir) == File.expand_path(Dir.home)
-          working_dir = File.expand_path("~/clacky_workspace")
+          default = config&.default_working_dir || File.expand_path("~/clacky_workspace")
+          working_dir = File.expand_path(default)
 
           # Create directory if it doesn't exist
           unless Dir.exist?(working_dir)
@@ -931,6 +889,98 @@ module Clacky
 
     end
 
+    # ── billing command ────────────────────────────────────────────────────────
+    desc "billing", "Show billing summary and usage statistics"
+    long_desc <<-LONGDESC
+      Display billing summary with token usage and cost breakdown.
+
+      Period options:
+        day    - Today's usage
+        week   - Last 7 days
+        month  - Current month (default)
+        year   - Current year
+        all    - All time
+
+      Examples:
+        $ clacky billing
+        $ clacky billing --period week
+        $ clacky billing --period all --json
+    LONGDESC
+    option :period, type: :string, default: "month",
+           desc: "Time period: day, week, month, year, all (default: month)"
+    option :json, type: :boolean, default: false,
+           desc: "Output as JSON"
+    option :days, type: :numeric, default: 30,
+           desc: "Number of days for daily breakdown (default: 30)"
+    option :help, type: :boolean, aliases: "-h", desc: "Show this help message"
+    def billing
+      if options[:help]
+        invoke :help, ["billing"]
+        return
+      end
+
+      require_relative "billing/billing_store"
+
+      store = Clacky::Billing::BillingStore.new
+      period = options[:period].to_sym
+      summary = store.summary(period: period)
+
+      if options[:json]
+        require "json"
+        puts JSON.pretty_generate(summary)
+        return
+      end
+
+      # Display formatted billing summary
+      puts ""
+      puts "📊 Billing Summary (#{period})"
+      puts "─" * 50
+      puts ""
+
+      # Total cost
+      cost_str = summary[:total_cost] > 0 ? "$#{format('%.4f', summary[:total_cost])}" : "$0.0000"
+      puts "  💰 Total Cost:       #{cost_str}"
+      puts "  📝 Total Tokens:     #{format_number(summary[:total_tokens])}"
+      puts "  📥 Prompt Tokens:    #{format_number(summary[:prompt_tokens])}"
+      puts "  📤 Completion:       #{format_number(summary[:completion_tokens])}"
+      puts "  🗄️  Cache Read:       #{format_number(summary[:cache_read_tokens])}"
+      puts "  📝 Cache Write:      #{format_number(summary[:cache_write_tokens])}"
+      puts "  🔢 API Requests:     #{summary[:record_count]}"
+      puts ""
+
+      # By model breakdown
+      if summary[:by_model] && !summary[:by_model].empty?
+        puts "📈 By Model:"
+        puts "─" * 50
+        summary[:by_model].each do |model, data|
+          cost = data.is_a?(Hash) ? data[:cost] : data
+          requests = data.is_a?(Hash) ? data[:requests] : "?"
+          puts "  #{model}"
+          puts "    Cost: $#{format('%.4f', cost)}  |  Requests: #{requests}"
+        end
+        puts ""
+      end
+
+      # Daily breakdown (last N days)
+      daily = store.daily_breakdown(days: [options[:days], 14].min)
+      recent_days = daily.select { |d| d[:cost] > 0 }.last(7)
+
+      if recent_days.any?
+        puts "📅 Recent Daily Usage:"
+        puts "─" * 50
+        recent_days.each do |day|
+          bar_len = [(day[:cost] * 100).to_i, 30].min
+          bar = "█" * bar_len
+          puts "  #{day[:date]}  $#{format('%.4f', day[:cost])}  #{bar}"
+        end
+        puts ""
+      end
+
+      puts "─" * 50
+      puts "  Data stored in: ~/.clacky/billing/"
+      puts ""
+    end
+
     # ── server command ─────────────────────────────────────────────────────────
     desc "server", "Start the Clacky web UI server"
     long_desc <<-LONGDESC
@@ -1008,8 +1058,8 @@ module Clacky
         $stdout = Clacky::Server::EPIPESafeIO.new($stdout)
         $stderr = Clacky::Server::EPIPESafeIO.new($stderr)
 
-        fd         = ENV["CLACKY_INHERIT_FD"].to_i
-        master_pid = ENV["CLACKY_MASTER_PID"].to_i
+        fd              = ENV["CLACKY_INHERIT_FD"].to_i
+        master_pid      = ENV["CLACKY_MASTER_PID"].to_i
         # Must use TCPServer.for_fd (not Socket.for_fd) so that accept_nonblock
         # returns a single Socket, not [Socket, Addrinfo] — WEBrick expects the former.
         socket     = TCPServer.for_fd(fd)

data/lib/clacky/default_skills/browser-setup/SKILL.md

@@ -19,6 +19,25 @@ allowed-tools:
 
 Configure the browser tool for Clacky. Config is stored at `~/.clacky/browser.yml`.
 
+## Region-Aware Download Links
+
+Whenever you show the user a link to download or upgrade Chrome/Edge, pick the right one for their region instead of always using google.com.
+
+Treat the user as **in China** when any of these is true:
+- The user is talking to you in Chinese
+- The system locale is Chinese (`echo $LANG` contains `zh_CN` / `zh_`)
+- A previous run of `install_browser.sh` reported `Region: china` (visible in its output)
+- `curl -s --max-time 3 https://www.google.com -o /dev/null -w "%{http_code}"` returns `000` while baidu.com works
+
+Use these links accordingly:
+
+| Region | Chrome | Edge |
+|---|---|---|
+| China | https://www.google.cn/chrome/ | https://www.microsoft.com/zh-cn/edge |
+| Global | https://www.google.com/chrome/ | https://www.microsoft.com/edge |
+
+When unsure, show **both** lines (label them "China:" and "Global:") so the user can pick.
+
 ## Command Parsing
 
 | User says | Subcommand |
@@ -197,9 +216,10 @@ Parse the version number:
   > ⚠️ Your browser version is v${VERSION}. Version 146+ is recommended for best compatibility.
   > Continuing anyway...
 - **version < 144 or "unknown"** → Stop:
-  > ❌ Browser version v${VERSION} is too old. Please upgrade Chrome or Edge to v146+ from:
-  > - Chrome: https://www.google.com/chrome/
-  > - Edge: https://www.microsoft.com/edge
+  > ❌ Browser version v${VERSION} is too old. Please upgrade Chrome or Edge to v146+.
+  >
+  > Use the download link from the **Region-Aware Download Links** section above
+  > (pick `China` or `Global` based on the user's region).
   >
   > After upgrading, run `/browser-setup` again.
 
@@ -363,7 +383,9 @@ Connection
 
 2. Upgrade your browser:
    - Chrome v142 is too old (need v146+)
-   - Download latest version: https://www.google.com/chrome/
+   - Pick the download link for the user's region from the
+     **Region-Aware Download Links** section at the top of this skill
+     (China users → google.cn; others → google.com).
 
 After fixing these issues, run `/browser-setup` again to verify.
 ```