openclacky 1.5.3 → 1.5.4

data/lib/clacky/server/project_manager.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "securerandom"
+require "time"
+
+module Clacky
+  module Server
+    # ProjectManager handles CRUD for "projects" — named groups that sessions
+    # can be assigned to, analogous to ChatGPT / Codex Projects.
+    #
+    # Storage: ~/.clacky/projects.json
+    # Each project entry shape:
+    #   {
+    #     id:          String (8-char hex),
+    #     name:        String,
+    #     description: String | null,
+    #     color:       String | null (e.g. "#6366f1"),
+    #     icon:        String | null (e.g. "folder", "code"),
+    #     working_dir: String | null (absolute path; new sessions inherit this),
+    #     created_at:  ISO8601,
+    #     updated_at:  ISO8601
+    #   }
+    #
+    # Thread-safety: a Mutex guards every read/write.
+    class ProjectManager
+      PROJECTS_FILE = File.join(Dir.home, ".clacky", "projects.json")
+
+      def initialize(projects_file: nil)
+        @projects_file = projects_file || PROJECTS_FILE
+        @mutex         = Mutex.new
+        @cache         = nil
+      end
+
+      # Return all projects sorted by created_at ascending (oldest first).
+      def all
+        @mutex.synchronize { load_projects.dup }
+      end
+
+      # Find a single project by id. Returns nil if not found.
+      def find(id)
+        @mutex.synchronize { load_projects.find { |p| p[:id] == id.to_s } }
+      end
+
+      # Create a new project. Returns the created project hash.
+      # Required: name. Optional: description, color, icon, working_dir.
+      def create(name:, description: nil, color: nil, icon: nil, working_dir: nil)
+        raise ArgumentError, "name is required" if name.to_s.strip.empty?
+
+        now     = Time.now.iso8601
+        project = {
+          id:          SecureRandom.hex(4),
+          name:        name.to_s.strip,
+          description: optional_str(description),
+          color:       optional_str(color),
+          icon:        optional_str(icon),
+          working_dir: optional_str(working_dir),
+          created_at:  now,
+          updated_at:  now
+        }
+
+        @mutex.synchronize do
+          projects = load_projects
+          projects << project
+          save_projects(projects)
+        end
+
+        project
+      end
+
+      # Update an existing project. Only explicitly passed (non-sentinel) keys
+      # are changed. Pass description: nil or color: nil or icon: nil or working_dir: nil to clear those fields.
+      # Returns updated project hash, or nil if not found.
+      def update(id, name: :__unset, description: :__unset, color: :__unset, icon: :__unset, working_dir: :__unset)
+        @mutex.synchronize do
+          projects = load_projects
+          project  = projects.find { |p| p[:id] == id.to_s }
+          return nil unless project
+
+          unless name == :__unset
+            raise ArgumentError, "name cannot be empty" if name.to_s.strip.empty?
+
+            project[:name] = name.to_s.strip
+          end
+          project[:description] = optional_str(description) unless description == :__unset
+          project[:color]       = optional_str(color)       unless color == :__unset
+          project[:icon]        = optional_str(icon)        unless icon == :__unset
+          project[:working_dir] = optional_str(working_dir) unless working_dir == :__unset
+          project[:updated_at]  = Time.now.iso8601
+
+          save_projects(projects)
+          project.dup
+        end
+      end
+
+      # Delete a project by id. Returns true if found and deleted, false otherwise.
+      # NOTE: caller is responsible for clearing project_id on orphaned sessions.
+      def delete(id)
+        @mutex.synchronize do
+          projects = load_projects
+          before   = projects.size
+          projects.reject! { |p| p[:id] == id.to_s }
+          return false if projects.size == before
+
+          save_projects(projects)
+          true
+        end
+      end
+
+      # ── Private helpers ───────────────────────────────────────────────────────
+
+      # Load from disk (or return []). NOT mutex-protected — must be called
+      # with @mutex held. Results cached until next save_projects.
+      private def load_projects
+        return @cache if @cache
+
+        unless File.exist?(@projects_file)
+          @cache = []
+          return @cache
+        end
+
+        begin
+          raw    = JSON.parse(File.read(@projects_file), symbolize_names: true)
+          @cache = Array(raw).sort_by { |p| p[:created_at].to_s }
+        rescue JSON::ParserError
+          @cache = []
+        end
+
+        @cache
+      end
+
+      # Persist to disk and refresh cache. NOT mutex-protected.
+      private def save_projects(projects)
+        FileUtils.mkdir_p(File.dirname(@projects_file))
+        File.write(@projects_file, JSON.pretty_generate(projects))
+        FileUtils.chmod(0o600, @projects_file)
+        @cache = projects
+      end
+
+      # Convert blank / nil values to nil for optional string fields.
+      private def optional_str(value)
+        return nil if value.nil?
+
+        s = value.to_s.strip
+        s.empty? ? nil : s
+      end
+    end
+  end
+end

data/lib/clacky/server/server_master.rb

@@ -4,6 +4,8 @@ require "socket"
 require "tmpdir"
 require_relative "../banner"
 require_relative "../version"
+require_relative "../agent_config"
+require_relative "../platform_http_client"
 
 module Clacky
   module Server
@@ -129,6 +131,11 @@ module Clacky
           "CLACKY_INHERIT_FD"  => @socket.fileno.to_s,
           "CLACKY_MASTER_PID"  => Process.pid.to_s
         }
+        selected_source = Clacky::AgentConfig.load.clacky_license_server.to_s.strip
+        unless selected_source.empty?
+          env["CLACKY_LICENSE_SERVER"] =
+            selected_source == Clacky::PlatformHttpClient::PRIMARY_HOST ? nil : selected_source
+        end
         # Keep the socket fd open across exec — mark it as non-CLOEXEC.
         @socket.close_on_exec = false
 

data/lib/clacky/server/session_registry.rb

@@ -203,7 +203,7 @@ module Clacky
       #   [ ...all_pinned_matching (newest-first), ...non_pinned (newest-first, limited) ]
       #
       # source and profile are orthogonal — either can be nil independently.
-      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true)
+      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true, project_id: nil, exclude_project: false, include_hidden: false)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
@@ -227,6 +227,10 @@ module Clacky
 
         all = @session_manager.all_sessions  # already sorted newest-first
 
+        # Hidden sessions (extension-managed) are excluded from the list by
+        # default; callers that need them pass include_hidden: true.
+        all = all.reject { |s| s[:hidden] } unless include_hidden
+
         # ── type filter (replaces old source/profile split) ──────────────────
         # type=coding  → agent_profile == "coding"
         # type=manual/cron/channel/setup → source match (profile=general implied)
@@ -244,6 +248,13 @@ module Clacky
           all = all.reject { |s| excluded.include?(s_source(s)) }
         end
 
+        # ── project_id filter — when provided, return ONLY sessions belonging
+        #    to the given project (no limit applied by default).
+        all = all.select { |s| s[:project_id].to_s == project_id.to_s } if project_id
+
+        # ── exclude_project filter — exclude sessions that belong to any project.
+        all = all.reject { |s| s[:project_id].to_s.strip != "" } if exclude_project
+
         # ── date filter (YYYY-MM-DD, matches created_at prefix) ──────────────
         all = all.select { |s| s[:created_at].to_s.start_with?(date) } if date
 
@@ -367,6 +378,7 @@ module Clacky
           reasoning_effort: ls&.dig(:reasoning_effort) || s.dig(:config, :reasoning_effort),
           pinned:        s[:pinned] || false,
           channel_info:  s[:channel_info],
+          project_id:    s[:project_id],
         }
       end
 
@@ -550,6 +562,7 @@ module Clacky
           agent_profile:   agent.agent_profile.name,
           pinned:          agent.pinned || false,
           latest_latency:  agent.latest_latency,
+          project_id:      agent.project_id,
         }
       end
     end

data/lib/clacky/session_manager.rb

@@ -64,6 +64,7 @@ module Clacky
       forked[:created_at]  = Time.now.iso8601
       forked[:updated_at]  = Time.now.iso8601
       forked[:pinned]      = false
+      forked[:hidden]      = false
       forked[:name]        = "#{original[:name] || "Unnamed session"} (copy)"
       forked[:stats] = (original[:stats] || {}).merge(
         total_tasks: 0, total_iterations: 0, total_cost_usd: 0.0,
@@ -328,12 +329,12 @@ module Clacky
       deleted
     end
 
-    # Keep only the most recent N non-pinned sessions by created_at; the rest
-    # are soft-deleted (moved to the session trash, recoverable). Pinned
-    # sessions are never deleted and do not count toward the cap.
+    # Keep only the most recent N non-pinned, non-hidden sessions by created_at;
+    # the rest are soft-deleted (moved to the session trash, recoverable). Pinned
+    # and hidden sessions are never deleted and do not count toward the cap.
     # Returns count of soft-deleted sessions.
     def cleanup_by_count(keep:, keep_cron: 200)
-      non_pinned = all_sessions.reject { |s| s[:pinned] } # already sorted newest-first
+      non_pinned = all_sessions.reject { |s| s[:pinned] || s[:hidden] } # already sorted newest-first
 
       cron, regular = non_pinned.partition { |s| s[:source].to_s == "cron" }
 

data/lib/clacky/tools/file_reader.rb

@@ -402,8 +402,9 @@ module Clacky
         message_lines << "Parser error: #{ref.parse_error}" if ref.parse_error
         if ref.parser_path
           expected_preview = "#{path}.preview.md"
+          interp = Utils::ParserManager.interpreter_for(File.basename(ref.parser_path))
           message_lines << "Parser script: #{ref.parser_path}"
-          message_lines << "To fix: edit the parser, then run: ruby #{ref.parser_path} #{path} > #{expected_preview}"
+          message_lines << "To fix: edit the parser, then run: #{interp} #{ref.parser_path} #{path} > #{expected_preview}"
           message_lines << "After a successful parse, re-run file_reader on this file."
         end
         {

data/lib/clacky/utils/model_pricing.rb

@@ -23,6 +23,39 @@ module Clacky
         }
       },
 
+      # Claude Sonnet 5 / Opus 5 (2026) — flat rate, no 200K tier (matches
+      # llm_proxy's costMap: single price regardless of prompt length).
+      # Source: openclacky-platform/llm_proxy/internal/proxy/proxy.go
+      "claude-sonnet-5" => {
+        input: {
+          default: 3.00,               # $3/MTok, same for all tiers
+          over_200k: 3.00
+        },
+        output: {
+          default: 15.00,              # $15/MTok, same for all tiers
+          over_200k: 15.00
+        },
+        cache: {
+          write: 3.75,                 # $3.75/MTok cache write
+          read: 0.30                   # $0.30/MTok cache read
+        }
+      },
+
+      "claude-opus-5" => {
+        input: {
+          default: 5.00,               # $5/MTok, same for all tiers
+          over_200k: 5.00
+        },
+        output: {
+          default: 25.00,              # $25/MTok, same for all tiers
+          over_200k: 25.00
+        },
+        cache: {
+          write: 6.25,                 # $6.25/MTok cache write
+          read: 0.50                   # $0.50/MTok cache read
+        }
+      },
+
       "claude-opus-4.5" => {
         input: {
           default: 5.00,              # $5/MTok for prompts ≤ 200K tokens
@@ -512,36 +545,45 @@ module Clacky
       },
 
       # MiniMax — USD per 1M tokens.
-      # Source: https://platform.minimaxi.com (Pay-as-You-Go).
-      # MiniMax pricing is identical across mainland (.com) and international
-      # (.io) endpoints, verified by the team. Same cache-write convention as
-      # DeepSeek/Kimi/GLM: bill writes at the input miss rate (OpenAI-compatible
-      # usage responses from MiniMax don't reliably carry a separate
-      # cache_creation_input_tokens field, so a distinct write rate would be
-      # dead code in practice).
-      # Note: providers.rb uses the capitalised "MiniMax-M2.x" model id, but
+      # Source: https://platform.minimax.io/docs/api-reference/api-overview
+      # (Pay-as-You-Go). MiniMax pricing is identical across the international
+      # (.io) and mainland China (.com) endpoints per the team's verification.
+      # Same cache-write convention as DeepSeek/Kimi/GLM: bill writes at the
+      # input miss rate (OpenAI-compatible usage responses from MiniMax don't
+      # reliably carry a separate cache_creation_input_tokens field, so a
+      # distinct write rate would be dead code in practice).
+      # Note: providers.rb uses the capitalised "MiniMax-M*" model id, but
       # the pricing table keys are lowercased to stay consistent with the
       # rest of this file; normalize_model_name() lowercases incoming model
       # names before lookup.
+
+      # M2.5 — high-throughput text model, optimised for coding and agent tasks
+      # (40,960-token context window). Listed at Pay-as-You-Go prices.
+      # Source: https://www.minimax.io/models/text (MiniMax-M2.5 product page).
       "minimax-m2.5" => {
         input:  { default: 0.30, over_200k: 0.30 },
         output: { default: 1.20, over_200k: 1.20 },
         cache:  { write: 0.30, read: 0.03 }
       },
 
-      # M3 (released 2026-06-01) is MiniMax's multimodal flagship. Official
-      # pricing is tiered by context length (≤512K vs 512K–1M); per the
-      # project's "displayed ≤ actual" convention we record only the lowest
-      # (≤512K) tier as a flat rate — the global TIERED_PRICING_THRESHOLD is
-      # 200K, so applying the 512K–1M rate to the 200K–512K band would over-
-      # charge. Listed at original (non-promotional) prices: input $0.60,
-      # output $2.40, cache read $0.12 per 1M tokens.
+      # M3 (released 2026-06-01) is MiniMax's multimodal flagship (image +
+      # video input, 1,000,000-token context window). Official pricing is
+      # tiered by context length (≤512K vs 512K–1M); per the project's
+      # "displayed ≤ actual" convention we record only the lowest (≤512K)
+      # tier as a flat rate — the global TIERED_PRICING_THRESHOLD is 200K,
+      # so applying the 512K–1M rate to the 200K–512K band would over-charge.
+      # Listed at original (non-promotional) prices: input $0.60, output
+      # $2.40, cache read $0.12 per 1M tokens; cache write is billed at the
+      # input miss rate.
       "minimax-m3" => {
         input:  { default: 0.60, over_200k: 0.60 },
         output: { default: 2.40, over_200k: 2.40 },
         cache:  { write: 0.60, read: 0.12 }
       },
 
+      # M2.7 — text-only model (204,800-token context window). Listed at
+      # original (non-promotional) prices: input $0.30, output $1.20, cache
+      # read $0.06 per 1M tokens; cache write billed at the input miss rate.
       "minimax-m2.7" => {
         input:  { default: 0.30, over_200k: 0.30 },
         output: { default: 1.20, over_200k: 1.20 },
@@ -741,6 +783,15 @@ module Clacky
         case model
         when /claude.*fable.*5/i
           "claude-fable-5"
+        # Claude Sonnet 5 / Opus 5 (2026) — anchored on the literal "sonnet-5"
+        # / "opus-5" substring (no "4" in between) so this never collides
+        # with "sonnet-4-5" / "opus-4-5", which are handled by the 4.x
+        # tiered-pricing branches below. Also matches Bedrock cross-region
+        # prefixes like "global.anthropic.claude-sonnet-5".
+        when /claude.*sonnet-5(?!\d)/i
+          "claude-sonnet-5"
+        when /claude.*opus-5(?!\d)/i
+          "claude-opus-5"
         when /claude.*opus.*4[.-]?[5-9]/i
           "claude-opus-4.5"
         when /claude.*sonnet.*4[.-]?[5-9]/i
@@ -804,14 +855,14 @@ module Clacky
           "glm-5"
         when /^glm-4\.7$/i
           "glm-4.7"
-        # MiniMax — model ids in providers.rb use capitalised "MiniMax-M2.x"
+        # MiniMax — model ids in providers.rb use capitalised "MiniMax-M*"
         # but we match case-insensitively and map to the lowercased table key.
         when /^minimax-m3$/i
           "minimax-m3"
-        when /^minimax-m2\.5$/i
-          "minimax-m2.5"
         when /^minimax-m2\.7$/i
           "minimax-m2.7"
+        when /^minimax-m2\.5(-highspeed)?$/i
+          "minimax-m2.5"
 
         # Qwen (Alibaba DashScope) — strict anchored match per registered
         # model id in providers.rb. qwen3.7-* is the latest flagship line;

data/lib/clacky/utils/parser_manager.rb

@@ -26,8 +26,8 @@ module Clacky
         ".pdf"  => "pdf_parser.rb",
         ".doc"  => "doc_parser.rb",
         ".docx" => "docx_parser.rb",
-        ".xlsx" => "xlsx_parser.rb",
-        ".xls"  => "xlsx_parser.rb",
+        ".xlsx" => "xlsx_parser.py",
+        ".xls"  => "xlsx_parser.py",
         ".pptx" => "pptx_parser.rb",
         ".ppt"  => "pptx_parser.rb",
         ".wps"  => "wps_parser.rb",
@@ -35,7 +35,17 @@ module Clacky
         ".dps"  => "wps_parser.rb",
       }.freeze
 
-      # Ensure ~/.clacky/parsers/ exists and all default parsers are present.
+      # Map a parser script's extension to the interpreter that runs it.
+      # Lets PARSER_FOR point at scripts in any language (see extract_version).
+      INTERPRETER_FOR = { ".rb" => RbConfig.ruby, ".py" => "python3" }.freeze
+
+      # Third-party libraries a given Python parser needs at runtime.
+      PYTHON_PARSER_LIBS = { "xlsx_parser.py" => "openpyxl" }.freeze
+
+      # Hard ceiling on how long a single parser subprocess may run. A runaway
+      # parser (huge/malformed file) is killed rather than hanging the caller
+      # forever and starving the machine.
+      PARSE_TIMEOUT = 60
       # Called at Agent startup (idempotent — safe to run every time).
       #
       # Copies every file from default_parsers/ (not just the entry-point .rb
@@ -137,17 +147,32 @@ module Clacky
                    parser_path: parser_path }
         end
 
-        raw_stdout, raw_stderr, status = Open3.capture3(RbConfig.ruby, parser_path, file_path)
+        interpreter = interpreter_for(script)
+
+        # Python parsers need Python + their libs present before parsing.
+        # ensure_python_deps returns an error string if python3 is missing or
+        # a lib can't be installed — the caller surfaces it as parse_error.
+        if interpreter == "python3"
+          dep_error = ensure_python_deps(script)
+          return { success: false, text: nil, error: dep_error, parser_path: parser_path } if dep_error
+        end
+
+        raw_stdout, raw_stderr, status =
+          capture3_with_timeout(interpreter, parser_path, file_path, timeout: PARSE_TIMEOUT)
 
         # capture3 returns ASCII-8BIT across the subprocess boundary on Ruby 2.6+.
         # Normalise both streams to UTF-8 immediately so all downstream code is clean.
-        stdout = Clacky::Utils::Encoding.to_utf8(raw_stdout)
-        stderr = Clacky::Utils::Encoding.to_utf8(raw_stderr)
+        stdout = Clacky::Utils::Encoding.to_utf8(raw_stdout.to_s)
+        stderr = Clacky::Utils::Encoding.to_utf8(raw_stderr.to_s)
 
         # Filter out Ruby/Bundler version warnings that pollute stderr
         clean_stderr = stderr.lines.reject { |l| l.match?(/warning:|already initialized constant/) }.join.strip
 
-        if status.success? && stdout.strip.length > 0
+        if status == :timeout
+          { success: false, text: nil,
+            error: "Parser timed out after #{PARSE_TIMEOUT}s (file too large or malformed)",
+            parser_path: parser_path }
+        elsif status.success? && stdout.strip.length > 0
           { success: true, text: stdout.strip, error: nil, parser_path: parser_path }
         else
           { success: false, text: nil,
@@ -156,6 +181,89 @@ module Clacky
         end
       end
 
+      # Map a parser script to its interpreter (Ruby, Python, ...).
+      def self.interpreter_for(script)
+        INTERPRETER_FOR[File.extname(script)] || RbConfig.ruby
+      end
+
+      # Run a subprocess with a hard timeout. On timeout the whole process
+      # GROUP is killed (TERM, 2s grace, then KILL) so grandchildren spawned
+      # by the parser die too. Mirrors mcp/stdio_transport.rb's kill sequence.
+      #
+      # Returns [stdout, stderr, status] — status is a Process::Status on
+      # normal exit, or the symbol :timeout when the subprocess was killed.
+      def self.capture3_with_timeout(*cmd, timeout:)
+        stdin, stdout, stderr, wait_thr = Open3.popen3(*cmd, pgroup: true)
+        stdin.close
+        pgid = Process.getpgid(wait_thr.pid)
+
+        out_thr = Thread.new { stdout.read }
+        err_thr = Thread.new { stderr.read }
+
+        if wait_thr.join(timeout)
+          [out_thr.value, err_thr.value, wait_thr.value]
+        else
+          kill_process_group(pgid)
+          out_thr.kill
+          err_thr.kill
+          [nil, "timed out", :timeout]
+        end
+      ensure
+        [stdout, stderr].each { |io| io&.close rescue nil }
+      end
+
+      # Terminate a process group: TERM, wait up to 2s, then KILL.
+      def self.kill_process_group(pgid)
+        Process.kill("TERM", -pgid)
+      rescue Errno::ESRCH, Errno::EPERM
+      else
+        deadline = Time.now + 2
+        sleep 0.05 while process_group_alive?(pgid) && Time.now < deadline
+        begin
+          Process.kill("KILL", -pgid) if process_group_alive?(pgid)
+        rescue Errno::ESRCH, Errno::EPERM
+        end
+      end
+
+      def self.process_group_alive?(pgid)
+        Process.kill(0, -pgid)
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+
+      # Ensure Python 3 and the libs a Python parser needs are present,
+      # installing on demand. Returns nil on success, or an error string.
+      #
+      # If python3 is missing, returns an error instructing the caller (the
+      # LLM via terminal tool) to run install_system_deps.sh --clt-only — we
+      # do NOT run it here because it blocks for 100+ seconds (CLT download).
+      # If python3 exists, probe + install the missing lib via pip --user.
+      def self.ensure_python_deps(script)
+        lib = PYTHON_PARSER_LIBS[script]
+
+        unless python3_available?
+          return "Python 3 is required to parse this file. " \
+                 "Run: bash ~/.clacky/scripts/install_system_deps.sh --clt-only\n" \
+                 "Then retry."
+        end
+
+        return nil if lib.nil? || python_lib_present?(lib)
+        pip_install(lib) ? nil : "Failed to install #{lib} (required to parse this file)."
+      end
+
+      def self.python3_available?
+        system("python3", "--version", out: File::NULL, err: File::NULL)
+      end
+
+      def self.python_lib_present?(lib)
+        system("python3", "-c", "import #{lib}", out: File::NULL, err: File::NULL)
+      end
+
+      def self.pip_install(lib)
+        system("python3", "-m", "pip", "install", "--user", lib, out: File::NULL, err: File::NULL)
+      end
+
       # Returns the path to a parser script for a given extension.
       # Used by agent to tell LLM where to find/modify the parser.
       def self.parser_path_for(ext)

data/lib/clacky/version.rb

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