openclacky 1.1.3 → 1.1.4

data/lib/clacky/server/http_server.rb

@@ -407,7 +407,7 @@ module Clacky
         when ["GET",    "/api/channels"]          then api_list_channels(res)
         when ["POST",   "/api/tool/browser"]      then api_tool_browser(req, res)
         when ["POST",   "/api/upload"]            then api_upload_file(req, res)
-        when ["POST",   "/api/open-file"]         then api_open_file(req, res)
+        when ["POST",   "/api/file-action"]       then api_file_action(req, res)
         when ["GET",    "/api/local-image"]       then api_serve_local_image(req, res)
         when ["GET",    "/api/version"]           then api_get_version(res)
         when ["POST",   "/api/version/upgrade"]   then api_upgrade_version(req, res)
@@ -448,6 +448,9 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/model$})
             session_id = path.sub("/api/sessions/", "").sub("/model", "")
             api_switch_session_model(session_id, req, res)
+          elsif method == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/reasoning_effort$})
+            session_id = path.sub("/api/sessions/", "").sub("/reasoning_effort", "")
+            api_switch_session_reasoning_effort(session_id, req, res)
           elsif method == "POST" && path.match?(%r{^/api/sessions/[^/]+/benchmark$})
             session_id = path.sub("/api/sessions/", "").sub("/benchmark", "")
             api_benchmark_session_models(session_id, req, res)
@@ -752,6 +755,9 @@ module Clacky
             else
               Clacky::Logger.debug("[Brand] async distribution refresh skipped/failed — #{result[:message]}")
             end
+            # Free-mode skill sync: branded + unactivated installs need their
+            # creator's free skills auto-installed for the "no serial number" UX.
+            brand.sync_free_skills_async!
           rescue StandardError => e
             Clacky::Logger.warn("[Brand] async distribution refresh raised: #{e.class}: #{e.message}")
           ensure
@@ -797,12 +803,30 @@ module Clacky
             refresh_pending = true
           end
 
+          # Free-mode counts: synchronous fetch is acceptable here because
+          # this endpoint is polled lazily and the platform call is cached
+          # via http keep-alive. On error we just return zero counts and the
+          # banner falls back to the legacy "not activated" message.
+          free_count  = 0
+          paid_count  = 0
+          begin
+            result = brand.fetch_free_skills!
+            if result[:success]
+              free_count = result[:skills].size
+              paid_count = result[:paid_skills_count].to_i
+            end
+          rescue StandardError
+            # Network errors are non-fatal here.
+          end
+
           json_response(res, 200, {
             branded:                       true,
             needs_activation:              true,
             product_name:                  brand.product_name,
             test_mode:                     @brand_test,
-            distribution_refresh_pending:  refresh_pending
+            distribution_refresh_pending:  refresh_pending,
+            free_skills_count:             free_count,
+            paid_skills_count:             paid_count
           })
           return
         end
@@ -918,7 +942,30 @@ module Clacky
         brand = Clacky::BrandConfig.load
 
         unless brand.activated?
-          json_response(res, 403, { ok: false, error: "License not activated" })
+          # Free-mode: branded but no license. Return the unencrypted skills
+          # available to anonymous installs so the Brand Skills tab is not
+          # empty and the user can install/use them without a serial number.
+          # Each skill is tagged is_free=true so the UI can show a "Free" badge.
+          result = brand.fetch_free_skills!
+
+          if result[:success]
+            free_skills = result[:skills].map { |s| s.merge("is_free" => true) }
+            json_response(res, 200, {
+              ok:                true,
+              skills:            free_skills,
+              free_mode:         true,
+              paid_skills_count: result[:paid_skills_count].to_i
+            })
+          else
+            json_response(res, 200, {
+              ok:                true,
+              skills:            [],
+              free_mode:         true,
+              paid_skills_count: 0,
+              warning_code:      "remote_unavailable",
+              warning:           result[:error] || "Could not reach the license server."
+            })
+          end
           return
         end
 
@@ -963,8 +1010,29 @@ module Clacky
       def api_brand_skill_install(slug, req, res)
         brand = Clacky::BrandConfig.load
 
+        # Free-mode: branded but not activated. Fall back to the public free
+        # skills endpoint and install with encrypted: false. Paid (encrypted)
+        # skills still require activation and will return 404 here.
         unless brand.activated?
-          json_response(res, 403, { ok: false, error: "License not activated" })
+          fetch_result = brand.fetch_free_skills!
+          unless fetch_result[:success]
+            json_response(res, 422, { ok: false, error: fetch_result[:error] })
+            return
+          end
+
+          skill_info = fetch_result[:skills].find { |s| s["name"] == slug }
+          unless skill_info
+            json_response(res, 404, { ok: false, error: "Skill '#{slug}' is not a free skill — activate your license to access it." })
+            return
+          end
+
+          result = brand.install_free_skill!(skill_info)
+          if result[:success]
+            @skill_loader = Clacky::SkillLoader.new(working_dir: nil, brand_config: brand)
+            json_response(res, 200, { ok: true, name: result[:name], version: result[:version] })
+          else
+            json_response(res, 422, { ok: false, error: result[:error] })
+          end
           return
         end
 
@@ -1304,7 +1372,11 @@ module Clacky
           sleep 0.5  # Let WEBrick flush the HTTP response
 
           if @master_pid
-            # Worker mode: tell master to hot-restart, then exit cleanly.
+            # Worker mode: tell master to hot-restart. Master will TERM us after the
+            # new worker boots; our trap("TERM") then runs shutdown_proc, which detaches
+            # the inherited listen socket before WEBrick shutdown. Do NOT exit(0) here —
+            # that bypasses trap handlers and lets the OS close(fd) on a socket shared
+            # with master+new worker, corrupting the listener on Linux/WSL.
             Clacky::Logger.info("[Restart] Sending USR1 to master (PID=#{@master_pid})")
             begin
               Process.kill("USR1", @master_pid)
@@ -1312,7 +1384,6 @@ module Clacky
               Clacky::Logger.warn("[Restart] Master PID=#{@master_pid} not found, falling back to exec.")
               standalone_exec_restart
             end
-            exit(0)
           else
             # Standalone mode (no master): fall back to the original exec approach.
             standalone_exec_restart
@@ -1549,12 +1620,16 @@ module Clacky
         json_response(res, 500, { ok: false, error: e.message })
       end
 
-      # POST /api/open-file
-      # Opens a local file or directory using the OS default handler.
-      # Used by the Web UI to handle file:// links — browsers block direct
-      # file:// navigation from http:// pages for security reasons.
-      def api_open_file(req, res)
-        path = parse_json_body(req)["path"]
+      # POST /api/file-action
+      # Unified file action endpoint — open locally or download.
+      # Body: { path: String, action: "open" | "download" }
+      #   open:     opens the file with the OS default handler (local deployments).
+      #   download: returns the file as a download (remote deployments).
+      def api_file_action(req, res)
+        body = parse_json_body(req)
+        path = body["path"]
+        action = body["action"] || "open"
+
         return json_response(res, 400, { error: "path is required" }) unless path && !path.empty?
 
         # Expand ~ to the user's home directory (e.g. "~/Desktop/file.pdf").
@@ -1567,13 +1642,33 @@ module Clacky
 
         return json_response(res, 404, { error: "file not found" }) unless File.exist?(linux_path)
 
-        result = Utils::EnvironmentDetector.open_file(linux_path)
-        return json_response(res, 501, { error: "unsupported OS" }) if result.nil?
-        json_response(res, 200, { ok: true })
+        case action
+        when "open"
+          result = Utils::EnvironmentDetector.open_file(linux_path)
+          return json_response(res, 501, { error: "unsupported OS" }) if result.nil?
+          json_response(res, 200, { ok: true })
+        when "download"
+          serve_file_download(res, linux_path)
+        else
+          json_response(res, 400, { error: "invalid action. Must be 'open' or 'download'" })
+        end
       rescue => e
         json_response(res, 500, { ok: false, error: e.message })
       end
 
+      # Stream a file to the client as a download.
+      # Content-Type is always application/octet-stream — the browser determines
+      # file type and handling from the filename extension in Content-Disposition.
+      def serve_file_download(res, path)
+        filename = File.basename(path)
+
+        res.status                  = 200
+        res["Content-Type"]         = "application/octet-stream"
+        res["Content-Disposition"]  = "attachment; filename=\"#{filename}\""
+        res["Content-Length"]       = File.size(path).to_s
+        res.body = File.binread(path)
+      end
+
       # GET /api/local-image?path=file:///path/to/image.png
       # GET /api/local-image?path=/path/to/image.png
       #
@@ -2999,6 +3094,26 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      # PATCH /api/sessions/:id/reasoning_effort
+      # Body: { "reasoning_effort": "off" | "low" | "medium" | "high" }
+      def api_switch_session_reasoning_effort(session_id, req, res)
+        body = parse_json_body(req)
+        raw = body["reasoning_effort"]
+        return json_response(res, 404, { error: "Session not found" }) unless @registry.ensure(session_id)
+
+        agent = nil
+        @registry.with_session(session_id) { |s| agent = s[:agent] }
+        return json_response(res, 404, { error: "Session not found" }) unless agent
+
+        agent.reasoning_effort = raw
+        @session_manager.save(agent.to_session_data)
+        broadcast_session_update(session_id)
+
+        json_response(res, 200, { ok: true, reasoning_effort: agent.reasoning_effort })
+      rescue => e
+        json_response(res, 500, { error: e.message })
+      end
+
       # POST /api/sessions/:id/benchmark
       #
       # Speed-test every configured model in one shot so the user can pick the

data/lib/clacky/server/session_registry.rb

@@ -165,11 +165,12 @@ module Clacky
             model_info = s[:agent]&.current_model_info
             live_name  = s[:agent]&.name
             live_name  = nil if live_name&.empty?
-            live_cost_source = s[:agent]&.cost_source
-            { status: s[:status], error: s[:error], model: model_info&.dig(:model), name: live_name,
-              total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
-              cost_source: live_cost_source,
-              latest_latency: s[:agent]&.latest_latency }
+          live_cost_source = s[:agent]&.cost_source
+          { status: s[:status], error: s[:error], model: model_info&.dig(:model), name: live_name,
+            total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
+            cost_source: live_cost_source,
+            reasoning_effort: s[:agent]&.reasoning_effort,
+            latest_latency: s[:agent]&.latest_latency }
           end
         end
 
@@ -241,6 +242,7 @@ module Clacky
           { status: s[:status], error: s[:error], model: model_info&.dig(:model),
             name: live_name, total_tasks: s[:agent]&.total_tasks,
             total_cost: s[:agent]&.total_cost, cost_source: s[:agent]&.cost_source,
+            reasoning_effort: s[:agent]&.reasoning_effort,
             latest_latency: s[:agent]&.latest_latency }
         end
 
@@ -271,6 +273,7 @@ module Clacky
           # per-assistant-message `latency` fields in messages[]. Reloaded
           # sessions start with nil and get populated on the next LLM call.
           latest_latency: ls&.dig(:latest_latency),
+          reasoning_effort: ls&.dig(:reasoning_effort) || s.dig(:config, :reasoning_effort),
           pinned:        s[:pinned] || false,
         }
       end
@@ -382,7 +385,7 @@ module Clacky
         return nil unless agent
 
         model_info = agent.current_model_info
-        
+
         {
           id:              session[:id],
           name:            agent.name,

data/lib/clacky/version.rb

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