openclacky 1.2.6 → 1.2.8

data/lib/clacky/server/session_registry.rb

@@ -40,6 +40,8 @@ module Clacky
           id:                   session_id,
           status:               :idle,
           error:                nil,
+          error_code:           nil,
+          top_up_url:           nil,
           updated_at:           Time.now,
           agent:                nil,
           ui:                   nil,
@@ -166,11 +168,15 @@ module Clacky
             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), model_id: model_info&.dig(:id), name: live_name,
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+            model: model_info&.dig(:model), model_id: model_info&.dig(:id), 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 }
+            latest_latency: s[:agent]&.latest_latency,
+            card_model: model_info&.dig(:card_model),
+            sub_model: model_info&.dig(:sub_model),
+            sub_model_options: sub_model_options_for(model_info) }
           end
         end
 
@@ -239,11 +245,15 @@ module Clacky
           model_info = s[:agent]&.current_model_info
           live_name  = s[:agent]&.name
           live_name  = nil if live_name&.empty?
-          { status: s[:status], error: s[:error], model: model_info&.dig(:model), model_id: model_info&.dig(:id),
+          { status: s[:status], error: s[:error], error_code: s[:error_code], top_up_url: s[:top_up_url],
+            model: model_info&.dig(:model), model_id: model_info&.dig(:id),
             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 }
+            latest_latency: s[:agent]&.latest_latency,
+            card_model: model_info&.dig(:card_model),
+            sub_model: model_info&.dig(:sub_model),
+            sub_model_options: sub_model_options_for(model_info) }
         end
 
         build_enriched_row(disk, live)
@@ -259,8 +269,13 @@ module Clacky
           name:          ls&.dig(:name) || s[:name] || "",
           status:        ls ? ls[:status].to_s : "idle",
           error:         ls ? ls[:error] : nil,
+          error_code:    ls&.dig(:error_code),
+          top_up_url:    ls&.dig(:top_up_url),
           model:         ls&.dig(:model),
           model_id:      ls&.dig(:model_id),
+          card_model:    ls&.dig(:card_model),
+          sub_model:     ls&.dig(:sub_model),
+          sub_model_options: ls&.dig(:sub_model_options) || [],
           source:        s_source(s),
           agent_profile: (s[:agent_profile] || "general").to_s,
           working_dir:   s[:working_dir],
@@ -280,6 +295,17 @@ module Clacky
       end
 
 
+      # Look up the provider preset for the session's current card and
+      # return the sub-model list. Empty when the card's base_url isn't
+      # in any preset (e.g. self-hosted custom endpoints) — the WebUI
+      # treats that as "no sub-model switcher available".
+      private def sub_model_options_for(model_info)
+        return [] unless model_info && model_info[:base_url]
+        provider_id = Clacky::Providers.find_by_base_url(model_info[:base_url])
+        return [] unless provider_id
+        Clacky::Providers.models(provider_id)
+      end
+
       # Normalize source field from a disk session hash.
       # "system" is a legacy value renamed to "setup" — treat them as equivalent.
       def s_source(s)

data/lib/clacky/server/web_ui_controller.rb

@@ -210,9 +210,12 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_warning(message) }
       end
 
-      def show_error(message)
-        emit("error", message: message)
-        forward_to_subscribers { |sub| sub.show_error(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)
+        forward_to_subscribers { |sub| sub.show_error(message, code: code, top_up_url: top_up_url) }
       end
 
       def show_success(message)

data/lib/clacky/shell_hook_loader.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "timeout"
+require "yaml"
+require "fileutils"
+
+module Clacky
+  # Loads declarative, shell-based hooks from ~/.clacky/hooks.yml and registers
+  # them on a HookManager. Each hook runs an external command rather than Ruby in
+  # the agent process, which keeps user-authored hooks sandboxed and safe.
+  #
+  # hooks.yml format:
+  #   hooks:
+  #     before_tool_use:
+  #       - name: guard            # optional label for logs
+  #         command: "~/.clacky/hook-scripts/guard.sh"
+  #         timeout: 10            # optional, seconds (default 10)
+  #     on_complete:
+  #       - command: "notify-send done"
+  #
+  # Runtime contract (per invocation):
+  #   - The event payload is passed to the command as JSON on STDIN.
+  #   - exit 0  → allow (default).
+  #   - exit 2  → deny; STDOUT becomes the denial reason. Only meaningful for
+  #               before_tool_use, which the agent checks for {action: :deny}.
+  #   - any other exit / timeout / crash → logged, treated as allow (a broken
+  #     hook must never wedge the agent).
+  class ShellHookLoader
+    DEFAULT_PATH    = File.expand_path("~/.clacky/hooks.yml")
+    DEFAULT_TIMEOUT = 10
+    DENY_EXIT_CODE  = 2
+
+    Result = Struct.new(:registered, :skipped, keyword_init: true)
+
+    def self.load_into(hook_manager, path: DEFAULT_PATH)
+      new(path: path).load_into(hook_manager)
+    end
+
+    # Create a starter hooks.yml plus an example guard script. Idempotent-ish:
+    # raises if hooks.yml already exists so we never clobber user config.
+    # @return [String] path to the created hooks.yml
+    def self.scaffold(path: DEFAULT_PATH)
+      raise ArgumentError, "hooks file already exists: #{path}" if File.exist?(path)
+
+      dir = File.dirname(path)
+      scripts_dir = File.join(dir, "hook-scripts")
+      FileUtils.mkdir_p(scripts_dir)
+
+      guard = File.join(scripts_dir, "deny-example.sh")
+      File.write(guard, <<~SH)
+        #!/usr/bin/env bash
+        # Example before_tool_use hook.
+        # Reads the event JSON on STDIN; exit 2 to DENY, exit 0 to ALLOW.
+        # STDOUT on exit 2 becomes the denial reason shown to the agent.
+        payload="$(cat)"
+        # Example: deny any terminal command containing "rm -rf /"
+        if echo "$payload" | grep -q 'rm -rf /'; then
+          echo "blocked dangerous command"
+          exit 2
+        fi
+        exit 0
+      SH
+      FileUtils.chmod("+x", guard)
+
+      File.write(path, <<~YAML)
+        # Declarative shell hooks. Each command receives the event payload as JSON
+        # on STDIN. For before_tool_use: exit 2 = deny (STDOUT = reason), exit 0 = allow.
+        # Events: #{HookManager::HOOK_EVENTS.join(", ")}
+        hooks:
+          before_tool_use:
+            - name: deny-example
+              command: "#{guard}"
+              timeout: 10
+        #  on_complete:
+        #    - command: "echo task finished"
+      YAML
+
+      path
+    end
+
+    def initialize(path: DEFAULT_PATH)
+      @path = path
+    end
+
+    # @return [Result] counts of registered hooks and skipped (with reasons)
+    def load_into(hook_manager)
+      result = Result.new(registered: [], skipped: [])
+      return result unless File.exist?(@path)
+
+      doc = YAMLCompat.load_file(@path) || {}
+      events = doc["hooks"] || {}
+
+      events.each do |event_name, specs|
+        event = event_name.to_sym
+        Array(specs).each do |spec|
+          register_one(hook_manager, event, spec, result)
+        end
+      end
+
+      result
+    rescue StandardError => e
+      Clacky::Logger.error("[ShellHookLoader] Failed to load #{@path}: #{e.message}")
+      result
+    end
+
+    private def register_one(hook_manager, event, spec, result)
+      command = spec["command"].to_s.strip
+      name    = spec["name"] || command
+      timeout = (spec["timeout"] || DEFAULT_TIMEOUT).to_i
+
+      if command.empty?
+        result.skipped << [name, "missing command"]
+        return
+      end
+
+      unless HookManager::HOOK_EVENTS.include?(event)
+        result.skipped << [name, "unknown event: #{event}"]
+        return
+      end
+
+      hook_manager.add(event) do |*args|
+        run_command(event, command, timeout, args)
+      end
+      result.registered << [event, name]
+    end
+
+    private def run_command(event, command, timeout, args)
+      payload = JSON.generate(build_payload(event, args))
+
+      out = +""
+      status = nil
+      Open3.popen3(command) do |stdin, stdout, _stderr, wait_thr|
+        stdin.write(payload)
+        stdin.close
+        if wait_thr.join(timeout)
+          out = stdout.read
+          status = wait_thr.value
+        else
+          Process.kill("TERM", wait_thr.pid) rescue nil
+          raise Timeout::Error
+        end
+      end
+
+      if status&.exitstatus == DENY_EXIT_CODE
+        { action: :deny, reason: out.strip.empty? ? "Denied by hook" : out.strip }
+      else
+        { action: :allow }
+      end
+    rescue Timeout::Error
+      Clacky::Logger.warn("[ShellHookLoader] Hook '#{command}' timed out after #{timeout}s — allowing")
+      { action: :allow }
+    rescue StandardError => e
+      Clacky::Logger.warn("[ShellHookLoader] Hook '#{command}' failed: #{e.message} — allowing")
+      { action: :allow }
+    end
+
+    # Normalize the positional trigger args of each event into a JSON-serializable hash.
+    private def build_payload(event, args)
+      base = { event: event.to_s }
+
+      case event
+      when :before_tool_use, :after_tool_use, :on_tool_error
+        base[:tool] = args[0]
+        base[:result] = args[1] if args.length > 1 && event == :after_tool_use
+        base[:error] = args[1].to_s if event == :on_tool_error && args[1]
+      when :on_start
+        base[:user_input] = args[0].to_s
+      when :on_iteration
+        base[:iteration] = args[0]
+      when :on_complete
+        base[:result] = args[0]
+      when :session_rollback
+        base[:info] = args[0]
+      end
+
+      base
+    end
+  end
+end

data/lib/clacky/tools/terminal.rb

@@ -340,12 +340,6 @@ module Clacky
           project_root: cwd || Dir.pwd
         )
 
-        # WSL interop fix: Windows .exe processes inherit the PTY's stdin fd
-        # and attempt to use it as a Windows Console, causing them to hang
-        # indefinitely. Redirect stdin from /dev/null for any .exe invocation
-        # that doesn't already have an explicit stdin redirect.
-        safe_command = redirect_exe_stdin(safe_command)
-
         # PowerShell 5 on Chinese Windows emits CP936/GBK by default; force
         # UTF-8 so our PTY (which decodes as UTF-8) doesn't see ??? bytes.
         safe_command = force_powershell_utf8(safe_command)
@@ -988,10 +982,31 @@ module Clacky
         # exit codes are also swallowed so the *user* command's $? is what
         # lands in `__clacky_ec`.
         hooks_line = with_hooks ? hooks_prefix_for(session) : ""
-        line   = %Q|#{hooks_line}{ #{command}\n}; __clacky_ec=$?; printf "\n__CLACKY_DONE_#{token}_%s__\n" "$__clacky_ec"\n|
+        # WSL interop fix: Windows .exe processes inherit the PTY slave fd
+        # as their stdin and treat it like a Windows Console — they sit
+        # there waiting for input nobody will ever send, hanging the whole
+        # session. Wrapping the user command's group with `</dev/null` gives
+        # every process inside it (including .exe interop children) an
+        # immediate EOF on stdin, so they exit cleanly.
+        #
+        # We only do this on WSL when the command actually mentions `.exe`,
+        # so Linux interactive commands like `read -p` / `python` REPL on
+        # non-WSL hosts (and on WSL when not invoking Windows binaries)
+        # keep their PTY stdin and continue to behave as before.
+        stdin_redirect = exe_needs_stdin_isolation?(command) ? " </dev/null" : ""
+        line   = %Q|#{hooks_line}{ #{command}\n}#{stdin_redirect}; __clacky_ec=$?; printf "\n__CLACKY_DONE_#{token}_%s__\n" "$__clacky_ec"\n|
         session.mutex.synchronize { session.writer.write(line) }
       end
 
+      # True when the command should run with stdin redirected from
+      # /dev/null. Currently only triggers on WSL when the command string
+      # mentions a Windows `.exe` binary — see write_user_command for the
+      # full rationale.
+      private def exe_needs_stdin_isolation?(command)
+        return false unless Clacky::Utils::EnvironmentDetector.wsl?
+        command.to_s =~ /\.exe\b/i ? true : false
+      end
+
       # Build the "run hooks" prefix line. Empty string for shells where
       # we don't know how to introspect hook registries.
       private def hooks_prefix_for(session)
@@ -1508,25 +1523,6 @@ module Clacky
         lines.last(DISPLAY_TAIL_LINES).join("\n")
       end
 
-      # WSL interop fix: Windows .exe processes inherit the PTY stdin fd
-      # and try to use it as a Windows Console, which hangs indefinitely.
-      # Detect .exe invocations and redirect stdin from /dev/null unless
-      # the command already has an explicit stdin redirect.
-      private def redirect_exe_stdin(command)
-        return command unless Clacky::Utils::EnvironmentDetector.wsl?
-        return command unless command =~ /\.exe\b/i
-        return command if command =~ /<\s*[^\s|&;]/
-
-        # If the command has a shell-level pipe, insert </dev/null before
-        # the first pipe so only the .exe segment gets its stdin redirected,
-        # rather than starving a downstream pipe reader (e.g. `tr`, `grep`).
-        if command =~ /\|/
-          command.sub(/\s*\|/, ' </dev/null |')
-        else
-          "#{command} </dev/null"
-        end
-      end
-
       # PowerShell 5 on Chinese Windows defaults [Console]::OutputEncoding
       # to CP936/GBK; our PTY decodes as UTF-8 so non-ASCII output becomes
       # `???`. Inject UTF-8 setup into the user's PowerShell command so the

data/lib/clacky/ui2/ui_controller.rb

@@ -861,7 +861,7 @@ module Clacky
 
       # Show error message
       # @param message [String] Error message
-      def show_error(message)
+      def show_error(message, code: nil, top_up_url: nil)
         output = @renderer.render_error(message)
         append_output(output)
       end

data/lib/clacky/ui_interface.rb

@@ -26,7 +26,7 @@ module Clacky
     # === Status messages ===
     def show_info(message, prefix_newline: true); end
     def show_warning(message); end
-    def show_error(message); end
+    def show_error(message, code: nil, top_up_url: nil); end
     def show_success(message); end
     def log(message, level: :info); end
 

data/lib/clacky/version.rb

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