openclacky 1.2.6 → 1.2.7

data/lib/clacky/server/channel/channel_manager.rb

@@ -234,7 +234,7 @@ module Clacky
         return if (text.nil? || text.empty?) && files.empty?
 
         # Handle built-in commands
-        if text&.start_with?("/")
+        if text&.match?(KNOWN_COMMAND) || text&.match?(/\A([\?h]|help)\z/i)
           handle_command(adapter, event, text)
           return
         end
@@ -249,7 +249,8 @@ module Clacky
           return
         end
 
-        Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]})")
+        sub_count = web_ui_for_session_diag(session_id)
+        Clacky::Logger.info("[ChannelManager] Routing to session #{session_id[0, 8]} (status=#{session[:status]}, text=#{text.inspect}, channel_subs=#{sub_count})")
 
         # If session is running, interrupt it automatically (mimics CLI behavior)
         if session[:status] == :running
@@ -283,7 +284,12 @@ module Clacky
 
         @run_agent_task.call(session_id, agent) do
           begin
+            Clacky::Logger.info("[ChannelManager] agent.run START session=#{session_id[0, 8]} text=#{text.inspect}")
             agent.run(text, files: files)
+            Clacky::Logger.info("[ChannelManager] agent.run END   session=#{session_id[0, 8]} text=#{text.inspect}")
+          rescue StandardError => e
+            Clacky::Logger.error("[ChannelManager] agent.run RAISED session=#{session_id[0, 8]} #{e.class}: #{e.message}\n#{e.backtrace.first(8).join("\n")}")
+            raise
           ensure
             adapter.stop_typing_keepalive(chat_id) if adapter.respond_to?(:stop_typing_keepalive)
           end
@@ -295,11 +301,24 @@ module Clacky
         key     = channel_key(event)
 
         case text
+        when /\A([\?h]|help)\z/i
+          adapter.send_text(chat_id, COMMAND_HELP)
+
+        when "/new", "/clear"
+          session_id = auto_create_session(adapter, event)
+          adapter.send_text(chat_id, "New session `#{session_id[0, 8]}` created.") if session_id
+
+        when /\A\/model\b/i
+          handle_model_command(adapter, event, text)
+
+        when /\A\/skills\b/i
+          handle_skills_command(adapter, event)
+
         when /\A\/bind\s+(\S+)\z/i
           arg = Regexp.last_match(1)
           # Support numeric index from /list (1-based)
           session_id = if arg =~ /\A\d+\z/
-            recent = @registry.list.last(5).reverse
+            recent = @registry.list.first(5)
             idx = arg.to_i - 1
             recent[idx]&.fetch(:id, nil)
           else
@@ -351,7 +370,9 @@ module Clacky
           session_id = resolve_session(event)
           if session_id
             session = @registry.get(session_id)
-            adapter.send_text(chat_id, "Bound to session `#{session_id[0, 8]}` (status: #{session&.dig(:status) || "unknown"})")
+            model = session&.dig(:agent)&.current_model_info
+            model_name = model&.dig(:model) || "unknown"
+            adapter.send_text(chat_id, "Bound to session `#{session_id[0, 8]}` (status: #{session&.dig(:status) || "unknown"}, model: #{model_name})")
           else
             adapter.send_text(chat_id, "No session bound yet. Send any message to auto-create one.")
           end
@@ -360,16 +381,118 @@ module Clacky
           list_sessions(adapter, chat_id)
 
         else
-          adapter.send_text(chat_id,
-            "Commands:\n" \
-            "  /bind <n|session_id> - switch to a session (use /list to see numbers)\n" \
-            "  /unbind - remove binding\n" \
-            "  /stop - interrupt current task\n" \
-            "  /status - show current binding\n" \
-            "  /list - show recent sessions")
+          adapter.send_text(chat_id, "Unknown command. Type ? for help.")
         end
       end
 
+      KNOWN_COMMAND = %r{\A/(new|clear|model|skills|bind|stop|unbind|status|list)\b}i
+
+      COMMAND_HELP = <<~HELP.strip
+        Commands:
+          ? / h / help - show this help
+          /new / /clear - start a new session
+          /model - show current model & available models
+          /model <n> - switch to model n
+          /skills - list available skills
+          /<skill> <args> - invoke a skill directly
+          /bind <n|session_id> - switch to a session (use /list to see numbers)
+          /unbind - remove binding
+          /stop - interrupt current task
+          /status - show current binding
+          /list - show recent sessions
+      HELP
+
+      def handle_model_command(adapter, event, text)
+        chat_id   = event[:chat_id]
+        session_id = resolve_session(event)
+
+        unless session_id
+          adapter.send_text(chat_id, "No session bound. Send any message to auto-create one first.")
+          return
+        end
+
+        session = @registry.get(session_id)
+        agent = session&.dig(:agent)
+        unless agent
+          adapter.send_text(chat_id, "Session not ready.")
+          return
+        end
+
+        arg = text.sub(/\A\/model\s*/i, "").strip
+
+        if arg.empty?
+          # Show current model and available list
+          info = agent.current_model_info
+          current = info&.dig(:model) || "unknown"
+          sub     = info&.dig(:sub_model)
+          card    = info&.dig(:card_model)
+          header  = "Current model: #{current}"
+          header += " (#{card} · #{sub})" if card && sub && sub != current
+          header += " (#{card})" if card && !sub
+
+          models = agent.available_models
+          if models.empty?
+            adapter.send_text(chat_id, "#{header}\nNo other models available.")
+            return
+          end
+
+          lines = models.each_with_index.map do |name, i|
+            marker = name == current ? " *" : ""
+            "#{i + 1}. #{name}#{marker}"
+          end
+          adapter.send_text(chat_id, "#{header}\n\nSwitch with /model <n>:\n#{lines.join("\n")}")
+        elsif arg =~ /\A\d+\z/
+          idx = arg.to_i - 1
+          models = agent.config.models
+          if idx < 0 || idx >= models.length
+            adapter.send_text(chat_id, "Invalid model number. Use /model to see available models.")
+            return
+          end
+
+          model_id = models[idx]["id"]
+          if agent.switch_model_by_id(model_id)
+            new_info = agent.current_model_info
+            adapter.send_text(chat_id, "Switched to #{new_info&.dig(:model) || model_id}.")
+          else
+            adapter.send_text(chat_id, "Failed to switch model.")
+          end
+        else
+          adapter.send_text(chat_id, "Usage: /model to list, /model <n> to switch.")
+        end
+      end
+
+      def handle_skills_command(adapter, event)
+        chat_id    = event[:chat_id]
+        session_id = resolve_session(event)
+
+        unless session_id
+          adapter.send_text(chat_id, "No session bound. Send any message to auto-create one first.")
+          return
+        end
+
+        session = @registry.get(session_id)
+        agent = session&.dig(:agent)
+        unless agent
+          adapter.send_text(chat_id, "Session not ready.")
+          return
+        end
+
+        skills = agent.skill_loader.user_invocable_skills
+          .reject { |s| s.source == :default }
+          .first(10)
+        if skills.empty?
+          adapter.send_text(chat_id, "No skills available.")
+          return
+        end
+
+        lines = skills.each_with_index.map do |s, i|
+          desc = s.description.to_s.strip
+          desc = desc.empty? ? "(no description)" : desc.length > 50 ? "#{desc[0..49]}..." : desc
+          "#{i + 1}. #{s.name} - #{desc}"
+        end
+        adapter.send_text(chat_id, "Skills:\n#{lines.join("\n")}")
+      end
+
       def resolve_session(event)
         key = channel_key(event)
         @registry.list.each do |summary|
@@ -411,6 +534,19 @@ module Clacky
         result
       end
 
+      def web_ui_for_session_diag(session_id)
+        result = nil
+        @registry.with_session(session_id) do |s|
+          ui = s[:ui]
+          result = if ui.respond_to?(:channel_subscribed?)
+            ui.instance_variable_get(:@channel_subscribers)&.size || 0
+          else
+            -1
+          end
+        end
+        result
+      end
+
       def bind_key_to_session(key, session_id)
         @registry.list.each do |summary|
           @registry.with_session(summary[:id]) { |s| s[:channel_keys]&.delete(key) }
@@ -422,7 +558,7 @@ module Clacky
       end
 
       def list_sessions(adapter, chat_id)
-        sessions = @registry.list.last(5).reverse
+        sessions = @registry.list.first(5)
         if sessions.empty?
           adapter.send_text(chat_id, "No sessions available.")
           return

data/lib/clacky/server/channel/channel_ui_controller.rb

@@ -145,8 +145,10 @@ module Clacky
         send_text("Warning: #{message}")
       end
 
-      def show_error(message)
-        send_text("Error: #{message}")
+      def show_error(message, code: nil, top_up_url: nil)
+        text = "Error: #{message}"
+        text += "\n#{top_up_url}" if top_up_url
+        send_text(text)
       end
 
       def show_success(message)

data/lib/clacky/server/http_server.rb

@@ -481,6 +481,9 @@ module Clacky
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/skills$})
             session_id = path.sub("/api/sessions/", "").sub("/skills", "")
             api_session_skills(session_id, res)
+          elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/files$})
+            session_id = path.sub("/api/sessions/", "").sub("/files", "")
+            api_session_files(session_id, req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/export$})
             session_id = path.sub("/api/sessions/", "").sub("/export", "")
             api_export_session(session_id, res)
@@ -496,6 +499,9 @@ module Clacky
           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 == "PATCH" && path.match?(%r{^/api/sessions/[^/]+/submodel$})
+            session_id = path.sub("/api/sessions/", "").sub("/submodel", "")
+            api_switch_session_submodel(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)
@@ -2445,7 +2451,56 @@ module Clacky
         json_response(res, 200, { skills: skill_data })
       end
 
-      # PATCH /api/skills/:name/toggle — enable or disable a skill
+      # GET /api/sessions/:id/files?path=<relative dir>
+      # Lists one directory level inside the session's working_dir (lazy, per-layer).
+      # Path traversal outside working_dir is rejected. Noisy dirs are hidden.
+      IGNORED_FILE_ENTRIES = %w[.git .svn .hg node_modules .DS_Store .bundle vendor/bundle tmp .sass-cache].freeze
+
+      def api_session_files(session_id, req, res)
+        unless @registry.ensure(session_id)
+          return json_response(res, 404, { error: "Session not found" })
+        end
+        session = @registry.get(session_id)
+        agent   = session && session[:agent]
+        return json_response(res, 404, { error: "Session not found" }) unless agent
+
+        root = File.expand_path(agent.working_dir.to_s)
+        return json_response(res, 404, { error: "Working directory not found" }) unless Dir.exist?(root)
+
+        rel = URI.decode_www_form(req.query_string.to_s).to_h["path"].to_s
+        rel = rel.sub(%r{\A/+}, "").strip
+        target = File.expand_path(File.join(root, rel))
+
+        # Reject traversal outside the working directory.
+        unless target == root || target.start_with?("#{root}/")
+          return json_response(res, 403, { error: "Path outside working directory" })
+        end
+        return json_response(res, 404, { error: "Directory not found" }) unless Dir.exist?(target)
+
+        entries = Dir.children(target).reject { |name| IGNORED_FILE_ENTRIES.include?(name) }
+
+        items = entries.filter_map do |name|
+          full = File.join(target, name)
+          is_dir = File.directory?(full)
+          # Skip symlinks pointing outside the root, and anything unreadable.
+          next unless File.exist?(full)
+          {
+            name:  name,
+            path:  rel.empty? ? name : "#{rel}/#{name}",
+            type:  is_dir ? "dir" : "file",
+            size:  is_dir ? nil : (File.size(full) rescue nil)
+          }
+        rescue StandardError
+          nil
+        end
+
+        # Directories first, then files; both case-insensitive alphabetical.
+        items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
+
+        json_response(res, 200, { root: root, path: rel, entries: items })
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
       # Body: { enabled: true/false }
       def api_toggle_skill(name, req, res)
         body    = parse_json_body(req)
@@ -3601,6 +3656,47 @@ module Clacky
         json_response(res, 500, { error: e.message })
       end
 
+      # PATCH /api/sessions/:id/submodel
+      # Body: { "model_name": "dsk-deepseek-v4-pro" | null }
+      #
+      # Pin this session to a sub-model under its current card without
+      # touching credentials or the global @models. Pass null/empty to clear
+      # and fall back to the card default. The name must appear in the
+      # provider preset's "models" list — anything else is rejected.
+      def api_switch_session_submodel(session_id, req, res)
+        body = parse_json_body(req)
+        raw = body["model_name"]
+        model_name = raw.is_a?(String) ? raw.strip : nil
+
+        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
+
+        if model_name && !model_name.empty?
+          info = agent.current_model_info
+          provider_id = info && Clacky::Providers.find_by_base_url(info[:base_url])
+          allowed = provider_id ? Clacky::Providers.models(provider_id) : []
+          if allowed.empty?
+            return json_response(res, 400, { error: "Current model has no provider preset; sub-model switching unavailable" })
+          end
+          unless allowed.include?(model_name)
+            return json_response(res, 400, { error: "Sub-model '#{model_name}' not listed under provider '#{provider_id}'" })
+          end
+        else
+          model_name = nil
+        end
+
+        agent.set_session_sub_model(model_name)
+        @session_manager.save(agent.to_session_data)
+        broadcast_session_update(session_id)
+
+        json_response(res, 200, { ok: true, sub_model: agent.current_model_info[:sub_model] })
+      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
@@ -3706,11 +3802,9 @@ module Clacky
 
         # Expand ~ to home directory
         expanded_dir = File.expand_path(new_dir)
-        
-        # Validate directory exists
-        unless Dir.exist?(expanded_dir)
-          return json_response(res, 400, { error: "Directory does not exist: #{expanded_dir}" })
-        end
+
+        # Auto-create the directory if it doesn't exist yet.
+        FileUtils.mkdir_p(expanded_dir)
 
         agent = nil
         @registry.with_session(session_id) { |s| agent = s[:agent] }
@@ -4189,12 +4283,18 @@ module Clacky
           broadcast(session_id, { type: "interrupted", session_id: session_id })
           @session_manager.save(agent.to_session_data(status: :interrupted))
         rescue => e
-          @registry.update(session_id, status: :error, error: e.message)
-          broadcast_session_update(session_id)
           # Route error through web_ui so channel subscribers (飞书/企微) receive it too.
           web_ui = nil
           @registry.with_session(session_id) { |s| web_ui = s[:ui] }
-          web_ui&.show_error(e.message)
+          code = e.is_a?(Clacky::InsufficientCreditError) ? e.error_code : nil
+          top_up_url = nil
+          if e.is_a?(Clacky::InsufficientCreditError) && e.provider_id
+            preset = Clacky::Providers::PRESETS[e.provider_id]
+            top_up_url = preset && preset["website_url"]
+          end
+          @registry.update(session_id, status: :error, error: e.message, error_code: code, top_up_url: top_up_url)
+          broadcast_session_update(session_id)
+          web_ui&.show_error(e.message, code: code, top_up_url: top_up_url)
           @session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
         end
         @registry.with_session(session_id) { |s| s[:thread] = thread }

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/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.7"
 end