openclacky 0.9.2 → 0.9.4

data/lib/clacky/default_skills/activate-license/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: activate-license
+description: Guide the user through activating their brand license key interactively.
+disable-model-invocation: true
+user-invocable: true
+---
+
+# Skill: activate-license
+
+## Purpose
+Guide the user to enter and submit their brand license key to activate the software.
+All structured input is gathered through `request_user_feedback` cards — no free-form interrogation.
+
+## Steps
+
+### 0. Detect language
+
+The skill is invoked with a `lang:` argument, e.g. `/activate-license lang:zh` or `/activate-license lang:en`.
+Check the invocation message:
+- If `lang:zh` is present → conduct entirely in **Chinese**.
+- Otherwise → use **English** throughout.
+
+Also check for a `name:` argument (e.g. `name:MyBrand`). Store as `brand_name` (default empty).
+
+### 1. Greet the user
+
+Send a short, warm welcome message. Use the language determined in Step 0.
+Do NOT ask for the key yet.
+
+Example (Chinese):
+> 👋 欢迎使用{{brand_name}}！
+> 只需输入您的授权码，即可解锁全部功能。授权码格式为：`XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX`
+
+Example (English):
+> 👋 Welcome to {{brand_name}}!
+> Enter your license key to unlock all features. The format is: `XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX`
+
+### 2. Ask for the license key (card)
+
+Call `request_user_feedback` to collect the license key.
+
+If `lang == "zh"`, use:
+```json
+{
+  "question": "请输入您的授权码：",
+  "options": []
+}
+```
+
+Otherwise (English):
+```json
+{
+  "question": "Please enter your license key:",
+  "options": []
+}
+```
+
+Store the user's reply as `license_key` (trimmed).
+
+### 3. Submit the license key via API
+
+Call the activation API using the shell tool:
+
+```bash
+curl -s -X POST http://localhost:PORT/api/brand/activate \
+  -H "Content-Type: application/json" \
+  -d '{"license_key": "LICENSE_KEY_HERE"}'
+```
+
+To find the running port, check the environment or use `http://localhost:7002` as the default.
+Try ports 7002, 7003, 7004 if the first fails. Parse the JSON response:
+- `ok: true` → activation succeeded, `brand_name` may be in response
+- `ok: false` → activation failed, `error` field contains the reason
+
+### 4a. On success
+
+If `lang == "zh"`, reply:
+> 🎉 授权激活成功！欢迎使用 {{brand_name}}。
+> 关闭此会话，即可开始使用全部功能。
+
+Otherwise:
+> 🎉 License activated successfully! Welcome to {{brand_name}}.
+> Close this session to start using all features.
+
+### 4b. On failure
+
+If the key format is invalid (doesn't match `XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX`):
+
+If `lang == "zh"`, reply and go back to Step 2:
+> ❌ 授权码格式不正确。正确格式为：`XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX-XXXXXXXX`
+> 请重新输入。
+
+If the API returns an error:
+
+If `lang == "zh"`, reply and go back to Step 2:
+> ❌ 激活失败：{{error}}
+> 请检查授权码后重试，或联系您的品牌服务商。
+
+Otherwise (English):
+> ❌ Activation failed: {{error}}
+> Please double-check your license key and try again, or contact your brand provider.
+
+### 5. Retry loop
+
+After a failure, call `request_user_feedback` again to let the user enter a corrected key.
+Repeat up to 3 times. If all 3 attempts fail, close gracefully:
+
+If `lang == "zh"`:
+> 多次尝试均未成功。请联系您的品牌服务商获取有效授权码。
+
+Otherwise:
+> Too many failed attempts. Please contact your brand provider for a valid license key.
+
+## Notes
+- Do NOT ask any questions beyond the license key card.
+- The key format is exactly: `[0-9A-Fa-f]{8}(-[0-9A-Fa-f]{8}){4}` (5 groups of 8 hex chars).
+- Never log or display the license key in cleartext beyond what the user already entered.
+- If the port cannot be determined, ask the user with `request_user_feedback`.

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

@@ -21,17 +21,6 @@ allowed-tools:
 
 Configure IM platform channels for open-clacky. Config is stored at `~/.clacky/channels.yml`.
 
-## Browser Automation Principles
-
-- **Always use built-in browser**: Pass `isolated: true` on every browser tool call. Do NOT ask the user to choose — use the built-in browser only.
-- **Never use `screenshot`**: Use `snapshot -i` instead to get page structure as text. Do NOT generate image files.
-- Use `open <url>` for navigation.
-- AI navigates; user performs form fills, clicks, and pastes when instructed.
-- If a login page or QR code appears, tell the user to log in and wait for "done" before continuing.
-- If stuck (CAPTCHA, unexpected page, dialog, cannot find a UI element), **guide the user to help** — ask the user to perform the specific step manually and reply "done" when ready.
-
----
-
 ## Command Parsing
 
 | User says | Subcommand |
@@ -77,7 +66,7 @@ Ask:
 #### Phase 1 — Open Feishu Open Platform
 
 1. Navigate: `open https://open.feishu.cn/app`. Pass `isolated: true`.
-2. Use `snapshot -i` to check page state. If a login page or QR code is shown, tell the user to log in and wait for "done".
+2. If a login page or QR code is shown, tell the user to log in and wait for "done".
 3. Confirm the app list is visible.
 
 #### Phase 2 — Create a new app
@@ -142,15 +131,13 @@ On success: "✅ Feishu channel configured. The channel is already active."
 ### WeCom setup
 
 1. Navigate: `open https://work.weixin.qq.com/wework_admin/frame#/aiHelper/create`. Pass `isolated: true`.
-2. Use `snapshot -i` to check page state. If a login page or QR code is shown, tell the user to log in and wait for "done".
+2. If a login page or QR code is shown, tell the user to log in and wait for "done".
 3. Steps 3–7: Do NOT take snapshots. Guide the user: "Scroll to the bottom of the right panel and click 'API mode creation'. Reply done." Wait for "done".
 4. Guide the user: "Click 'Add' next to 'Visible Range'. In the scope dialog, select the top-level company node (or specific users/departments). Click Confirm. Reply done." Wait for "done".
 5. Guide the user: "If Secret is not visible, click 'Get Secret'. Copy Bot ID and Secret **before** clicking Save — do NOT click 'Get Secret' again after copying (it invalidates the previous secret). Paste here. Reply with: Bot ID: xxx, Secret: xxx" Wait for "done".
 6. Guide the user: "Click Save. In the dialog, enter name (e.g. Open Clacky) and description (e.g. AI assistant powered by open-clacky). Click Confirm. Click Save again. Reply done." Wait for "done".
 7. **Apply config and hot-reload** — Parse credentials from step 5. Trim leading/trailing whitespace from bot_id and secret. Run `curl -X POST http://localhost:7070/api/channels/wecom -H "Content-Type: application/json" -d '{"bot_id":"...","secret":"..."}'`. Ensure bot_id (starts with `aib`) and secret (longer string) are not swapped.
 
-On success: "✅ WeCom channel configured."
-
 On success: "✅ WeCom channel configured. To use the bot: WeCom client → Contacts → select Smart Bot to see the newly created bot.".
 
 ---
@@ -188,13 +175,16 @@ Say: "❌ `<platform>` channel disabled. Restart `clacky server` to deactivate."
 Check each item, report ✅ / ❌ with remediation:
 
 1. **Config file** — does `~/.clacky/channels.yml` exist and is it readable?
-2. **Permissions** — `stat ~/.clacky/channels.yml`, warn if not 600.
-3. **Required keys** — for each enabled platform:
+2. **Required keys** — for each enabled platform:
    - Feishu: `app_id`, `app_secret` present and non-empty
    - WeCom: `bot_id`, `secret` present and non-empty
-4. **Feishu credentials** (if enabled) — run the token API call, check `code=0`.
-5. **WeCom** — no REST check (verified at connect), just confirm keys are present.
-6. **Server running** — `pgrep -f "clacky server"`. Channels only activate when the server is running.
+3. **Feishu credentials** (if enabled) — run the token API call, check `code=0`.
+4. **WeCom credentials** (if enabled) — search today's log for auth-related lines:
+   ```bash
+   grep -iE "wecom adapter loop started|WeCom authentication failed|WeCom WS error response|WecomAdapter" ~/.clacky/logger/clacky-$(date +%Y-%m-%d).log
+   ```
+   - If output contains `WeCom authentication failed` or `WeCom WS error response` with non-zero errcode: ❌ "WeCom Bot ID or Secret is incorrect — re-run `/channel-setup reconfigure`"
+   - If output contains `[ChannelManager] :wecom adapter loop started` with no auth error after it: ✅
 
 ---
 

data/lib/clacky/message_format/anthropic.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module Clacky
+  module MessageFormat
+    # Static helpers for Anthropic API message format.
+    #
+    # Responsibilities:
+    #   - Identify Anthropic-style messages stored in @messages
+    #   - Convert internal @messages → Anthropic API request body
+    #   - Parse Anthropic API response → internal format
+    #   - Format tool results for the next turn
+    #
+    # Internal @messages always use OpenAI-style canonical format:
+    #   assistant tool_calls: { role: "assistant", tool_calls: [{id:, function:{name:,arguments:}}] }
+    #   tool result:          { role: "tool", tool_call_id:, content: }
+    #
+    # This module converts that canonical format to Anthropic native on the way OUT,
+    # and converts Anthropic native back to canonical on the way IN.
+    module Anthropic
+      module_function
+
+      # ── Message type identification ───────────────────────────────────────────
+
+      # Returns true if the message is an Anthropic-native tool result stored in
+      # @messages (role: "user" with content array containing tool_result blocks).
+      # NOTE: After the refactor, new tool results are stored in canonical format
+      # (role: "tool"). This helper handles legacy messages that might exist in
+      # older sessions.
+      def tool_result_message?(msg)
+        msg[:role] == "user" &&
+          msg[:content].is_a?(Array) &&
+          msg[:content].any? { |b| b.is_a?(Hash) && b[:type] == "tool_result" }
+      end
+
+      # Returns the tool_use_ids referenced in an Anthropic-native tool result message.
+      def tool_use_ids(msg)
+        return [] unless tool_result_message?(msg)
+
+        msg[:content].select { |b| b[:type] == "tool_result" }.map { |b| b[:tool_use_id] }
+      end
+
+      # ── Request building ──────────────────────────────────────────────────────
+
+      # Convert canonical @messages + tools into an Anthropic API request body.
+      # @param messages [Array<Hash>] canonical messages (may include system)
+      # @param model    [String]
+      # @param tools    [Array<Hash>] OpenAI-style tool definitions
+      # @param max_tokens [Integer]
+      # @param caching_enabled [Boolean]
+      # @return [Hash] ready to serialize as JSON body
+      def build_request_body(messages, model, tools, max_tokens, caching_enabled)
+        system_messages = messages.select { |m| m[:role] == "system" }
+        regular_messages = messages.reject { |m| m[:role] == "system" }
+
+        system_text = system_messages.map { |m| extract_text(m[:content]) }.join("\n\n")
+
+        api_messages = regular_messages.map { |msg| to_api_message(msg, caching_enabled) }
+        api_tools    = tools&.map { |t| to_api_tool(t) }
+
+        if caching_enabled && api_tools&.any?
+          api_tools.last[:cache_control] = { type: "ephemeral" }
+        end
+
+        body = { model: model, max_tokens: max_tokens, messages: api_messages }
+        body[:system] = system_text unless system_text.empty?
+        body[:tools]  = api_tools   if api_tools&.any?
+        body
+      end
+
+      # ── Response parsing ──────────────────────────────────────────────────────
+
+      # Parse Anthropic API response into canonical internal format.
+      # @param data [Hash] parsed JSON response body
+      # @return [Hash] canonical response: { content:, tool_calls:, finish_reason:, usage: }
+      def parse_response(data)
+        blocks  = data["content"] || []
+        usage   = data["usage"]   || {}
+
+        content = blocks.select { |b| b["type"] == "text" }.map { |b| b["text"] }.join("")
+
+        # tool_calls use canonical format (id, function: {name, arguments})
+        tool_calls = blocks.select { |b| b["type"] == "tool_use" }.map do |tc|
+          args = tc["input"].is_a?(String) ? tc["input"] : tc["input"].to_json
+          { id: tc["id"], type: "function", name: tc["name"], arguments: args }
+        end
+
+        finish_reason = case data["stop_reason"]
+                        when "end_turn"   then "stop"
+                        when "tool_use"   then "tool_calls"
+                        when "max_tokens" then "length"
+                        else data["stop_reason"]
+                        end
+
+        usage_data = {
+          prompt_tokens:      usage["input_tokens"],
+          completion_tokens:  usage["output_tokens"],
+          total_tokens:       usage["input_tokens"].to_i + usage["output_tokens"].to_i
+        }
+        usage_data[:cache_read_input_tokens]     = usage["cache_read_input_tokens"]     if usage["cache_read_input_tokens"]
+        usage_data[:cache_creation_input_tokens] = usage["cache_creation_input_tokens"] if usage["cache_creation_input_tokens"]
+
+        { content: content, tool_calls: tool_calls, finish_reason: finish_reason,
+          usage: usage_data, raw_api_usage: usage }
+      end
+
+      # ── Tool result formatting ────────────────────────────────────────────────
+
+      # Format tool results into canonical messages to append to @messages.
+      # Input:  response (canonical, has :tool_calls), tool_results array
+      # Output: canonical messages: [{ role: "tool", tool_call_id:, content: }]
+      def format_tool_results(response, tool_results)
+        results_map = tool_results.each_with_object({}) { |r, h| h[r[:id]] = r }
+
+        response[:tool_calls].map do |tc|
+          result = results_map[tc[:id]]
+          {
+            role: "tool",
+            tool_call_id: tc[:id],
+            content: result ? result[:content] : { error: "Tool result missing" }.to_json
+          }
+        end
+      end
+
+      # ── Private helpers ───────────────────────────────────────────────────────
+
+      # Convert a single canonical message to Anthropic API format.
+      # caching_enabled is kept for signature compatibility but is no longer used here —
+      # cache_control markers are embedded into messages by Client#apply_message_caching
+      # before build_request_body is called.
+      private_class_method def self.to_api_message(msg, _caching_enabled)
+        role      = msg[:role]
+        content   = msg[:content]
+        tool_calls = msg[:tool_calls]
+
+        # assistant with tool_calls → content blocks with tool_use
+        if role == "assistant" && tool_calls&.any?
+          blocks = []
+          blocks << { type: "text", text: content } if content.is_a?(String) && !content.empty?
+          blocks.concat(content_to_blocks(content)) if content.is_a?(Array)
+
+          tool_calls.each do |tc|
+            func  = tc[:function] || tc
+            name  = func[:name]  || tc[:name]
+            raw_args = func[:arguments] || tc[:arguments]
+            input = raw_args.is_a?(String) ? JSON.parse(raw_args) : raw_args
+            blocks << { type: "tool_use", id: tc[:id], name: name, input: input || {} }
+          end
+
+          return { role: "assistant", content: blocks }
+        end
+
+        # canonical tool result (role: "tool") → Anthropic user message with tool_result block
+        if role == "tool"
+          block = { type: "tool_result", tool_use_id: msg[:tool_call_id], content: msg[:content] }
+          return { role: "user", content: [block] }
+        end
+
+        # legacy Anthropic-native tool result already in user+tool_result format — pass through
+        if role == "user" && content.is_a?(Array) && content.any? { |b| b.is_a?(Hash) && b[:type] == "tool_result" }
+          return { role: "user", content: content }
+        end
+
+        # regular user/assistant message
+        # NOTE: cache_control markers are applied by Client#apply_message_caching before
+        # build_request_body is called. We must NOT add extra cache_control here, because:
+        #   1. apply_message_caching already placed the marker on the correct breakpoint message.
+        #   2. Adding cache_control to every user message causes Anthropic to treat every
+        #      user message as a cache breakpoint, which invalidates the intended cache boundary
+        #      and results in cache misses (cache_read=0) every turn.
+        blocks = content_to_blocks(content)
+        { role: role, content: blocks }
+      end
+
+      # Convert content (String or Array) to Anthropic content block array.
+      # cache_control markers already embedded by Client#apply_message_caching are preserved.
+      private_class_method def self.content_to_blocks(content)
+        case content
+        when String
+          [{ type: "text", text: content }]
+        when Array
+          content.map { |b| normalize_block(b) }.compact
+        else
+          [{ type: "text", text: content.to_s }]
+        end
+      end
+
+      # Normalize a single content block to Anthropic format.
+      private_class_method def self.normalize_block(block)
+        return block unless block.is_a?(Hash)
+
+        case block[:type]
+        when "text"
+          # Preserve cache_control if present (placed by Client#apply_message_caching)
+          result = { type: "text", text: block[:text] }
+          result[:cache_control] = block[:cache_control] if block[:cache_control]
+          result
+        when "image_url"
+          url = block.dig(:image_url, :url) || block[:url]
+          url_to_image_block(url)
+        when "image"
+          block  # already Anthropic format
+        when "tool_result", "tool_use"
+          block  # pass through
+        else
+          block
+        end
+      end
+
+      # Convert an image URL to Anthropic image block.
+      private_class_method def self.url_to_image_block(url)
+        return nil unless url
+
+        if url.start_with?("data:")
+          match = url.match(/^data:([^;]+);base64,(.*)$/)
+          if match
+            { type: "image", source: { type: "base64", media_type: match[1], data: match[2] } }
+          else
+            { type: "image", source: { type: "url", url: url } }
+          end
+        else
+          { type: "image", source: { type: "url", url: url } }
+        end
+      end
+
+      # Convert OpenAI-style tool definition to Anthropic format.
+      private_class_method def self.to_api_tool(tool)
+        func = tool[:function] || tool
+        { name: func[:name], description: func[:description], input_schema: func[:parameters] }
+      end
+
+      # Extract plain text from content (String or Array).
+      private_class_method def self.extract_text(content)
+        case content
+        when String then content
+        when Array  then content.map { |b| b.is_a?(Hash) ? (b[:text] || "") : b.to_s }.join("\n")
+        else             content.to_s
+        end
+      end
+    end
+  end
+end

data/lib/clacky/message_format/open_ai.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Clacky
+  module MessageFormat
+    # Static helpers for OpenAI-compatible API message format.
+    #
+    # The canonical internal @messages format IS OpenAI format, so this module
+    # mainly handles response parsing, tool result formatting, and message
+    # type identification — minimal transformation needed.
+    module OpenAI
+      module_function
+
+      # ── Message type identification ───────────────────────────────────────────
+
+      # Returns true if the message is a canonical tool result.
+      def tool_result_message?(msg)
+        msg[:role] == "tool" && !msg[:tool_call_id].nil?
+      end
+
+      # Returns the tool_call_ids referenced in a tool result message.
+      def tool_call_ids(msg)
+        return [] unless tool_result_message?(msg)
+
+        [msg[:tool_call_id]]
+      end
+
+      # ── Request building ──────────────────────────────────────────────────────
+
+      # Build an OpenAI-compatible request body.
+      # Canonical messages are already in OpenAI format — no conversion needed.
+      # @param messages [Array<Hash>] canonical messages
+      # @param model    [String]
+      # @param tools    [Array<Hash>] OpenAI-style tool definitions
+      # @param max_tokens [Integer]
+      # @param caching_enabled [Boolean] (only effective for Claude via OpenRouter)
+      # @return [Hash]
+      def build_request_body(messages, model, tools, max_tokens, caching_enabled)
+        body = { model: model, max_tokens: max_tokens, messages: messages }
+
+        if tools&.any?
+          if caching_enabled
+            cached_tools = deep_clone(tools)
+            cached_tools.last[:cache_control] = { type: "ephemeral" }
+            body[:tools] = cached_tools
+          else
+            body[:tools] = tools
+          end
+        end
+
+        body
+      end
+
+      # ── Response parsing ──────────────────────────────────────────────────────
+
+      # Parse OpenAI-compatible API response into canonical internal format.
+      # @param data [Hash] parsed JSON response body
+      # @return [Hash]
+      def parse_response(data)
+        message       = data["choices"].first["message"]
+        usage         = data["usage"] || {}
+        raw_api_usage = usage.dup
+
+        usage_data = {
+          prompt_tokens:     usage["prompt_tokens"],
+          completion_tokens: usage["completion_tokens"],
+          total_tokens:      usage["total_tokens"]
+        }
+
+        usage_data[:api_cost]                    = usage["cost"]                            if usage["cost"]
+        usage_data[:cache_creation_input_tokens] = usage["cache_creation_input_tokens"]     if usage["cache_creation_input_tokens"]
+        usage_data[:cache_read_input_tokens]     = usage["cache_read_input_tokens"]         if usage["cache_read_input_tokens"]
+
+        # OpenRouter stores cache info under prompt_tokens_details
+        if (details = usage["prompt_tokens_details"])
+          usage_data[:cache_read_input_tokens]     = details["cached_tokens"]    if details["cached_tokens"].to_i > 0
+          usage_data[:cache_creation_input_tokens] = details["cache_write_tokens"] if details["cache_write_tokens"].to_i > 0
+        end
+
+        result = {
+          content:       message["content"],
+          tool_calls:    parse_tool_calls(message["tool_calls"]),
+          finish_reason: data["choices"].first["finish_reason"],
+          usage:         usage_data,
+          raw_api_usage: raw_api_usage
+        }
+
+        # Preserve reasoning_content (e.g. Kimi/Moonshot extended thinking)
+        result[:reasoning_content] = message["reasoning_content"] if message["reasoning_content"]
+
+        result
+      end
+
+      # ── Tool result formatting ────────────────────────────────────────────────
+
+      # Format tool results into canonical messages to append to @messages.
+      # @return [Array<Hash>] canonical tool messages
+      def format_tool_results(response, tool_results)
+        results_map = tool_results.each_with_object({}) { |r, h| h[r[:id]] = r }
+
+        response[:tool_calls].map do |tc|
+          result = results_map[tc[:id]]
+          {
+            role:         "tool",
+            tool_call_id: tc[:id],
+            content:      result ? result[:content] : { error: "Tool result missing" }.to_json
+          }
+        end
+      end
+
+      # ── Private helpers ───────────────────────────────────────────────────────
+
+      private_class_method def self.parse_tool_calls(raw)
+        return nil if raw.nil? || raw.empty?
+
+        raw.filter_map do |call|
+          func = call["function"] || {}
+          name = func["name"]
+          arguments = func["arguments"]
+          # Skip malformed tool calls where name or arguments is nil (broken API response)
+          next if name.nil? || arguments.nil?
+
+          { id: call["id"], type: call["type"], name: name, arguments: arguments }
+        end
+      end
+
+      private_class_method def self.deep_clone(obj)
+        case obj
+        when Hash  then obj.each_with_object({}) { |(k, v), h| h[k] = deep_clone(v) }
+        when Array then obj.map { |item| deep_clone(item) }
+        else obj
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/channel/adapters/wecom/adapter.rb

@@ -50,6 +50,8 @@ module Clacky
             @ws_client.start do |raw|
               handle_raw_message(raw)
             end
+          rescue WSClient::AuthError => e
+            Clacky::Logger.warn("[WecomAdapter] Authentication failed, not retrying: #{e.message}")
           end
 
           def stop

data/lib/clacky/server/channel/adapters/wecom/ws_client.rb

@@ -23,6 +23,9 @@ module Clacky
           HEARTBEAT_INTERVAL = 30 # seconds
           RECONNECT_DELAY = 5     # seconds
 
+          # Raised when WeCom rejects credentials — signals caller not to retry.
+          class AuthError < StandardError; end
+
           def initialize(bot_id:, secret:, ws_url: WS_URL)
             @bot_id = bot_id
             @secret = secret
@@ -39,6 +42,10 @@ module Clacky
             while @running
               begin
                 connect_and_listen
+              rescue AuthError => e
+                warn "WeCom authentication error (not retrying): #{e.message}"
+                @running = false
+                raise
               rescue => e
                 warn "WeCom WebSocket error: #{e.message}"
                 sleep RECONNECT_DELAY if @running
@@ -139,6 +146,12 @@ module Clacky
               errcode = frame["errcode"] || body["errcode"]
               if errcode && errcode != 0
                 warn "WeCom WS error response: #{frame.inspect}"
+                # Auth failures are fatal — stop reconnecting and surface the error
+                if req_id.start_with?("subscribe_")
+                  errmsg = frame["errmsg"] || body["errmsg"] || "unknown error"
+                  @running = false
+                  raise AuthError, "WeCom authentication failed (errcode=#{errcode}): #{errmsg}"
+                end
               end
             end
           rescue JSON::ParserError => e

data/lib/clacky/server/http_server.rb

@@ -14,6 +14,7 @@ require_relative "web_ui_controller"
 require_relative "scheduler"
 require_relative "../brand_config"
 require_relative "channel"
+require_relative "../banner"
 
 module Clacky
   module Server
@@ -220,7 +221,11 @@ module Clacky
           end
         end
 
-        puts "🌐 Clacky Web UI running at http://#{@host}:#{@port}"
+        banner = Clacky::Banner.new
+        puts banner.colored_cli_logo
+        puts banner.colored_tagline
+        puts ""
+        puts "   Web UI: #{banner.highlight("http://#{@host}:#{@port}")}"
         puts "   Version: #{Clacky::VERSION}"
         puts "   Press Ctrl-C to stop."
 
@@ -229,7 +234,7 @@ module Clacky
 
         # Start the background scheduler
         @scheduler.start
-        puts "   ⏰ Scheduler started (#{@scheduler.schedules.size} schedule(s) loaded)"
+        puts "   Scheduler: #{@scheduler.schedules.size} task(s) loaded"
 
         # Start IM channel adapters (non-blocking — each platform runs in its own thread)
         @channel_manager.start
@@ -443,6 +448,11 @@ module Clacky
           warning = "Your #{brand.brand_name} license has expired. Please renew to continue."
         elsif brand.grace_period_exceeded?
           warning = "License server unreachable for more than 3 days. Please check your connection."
+        elsif brand.license_expires_at && !brand.expired?
+          days_remaining = ((brand.license_expires_at - Time.now.utc) / 86_400).ceil
+          if days_remaining <= 7
+            warning = "Your #{brand.brand_name} license expires in #{days_remaining} day#{"s" if days_remaining != 1}. Please renew soon."
+          end
         end
 
         json_response(res, 200, {

data/lib/clacky/session_manager.rb

@@ -31,8 +31,13 @@ module Clacky
 
       @last_saved_path = filepath
 
-      # Keep only the most recent 10 sessions
-      cleanup_by_count(keep: 10)
+      # Keep only the most recent 10 sessions (best-effort, never block save)
+      begin
+        cleanup_by_count(keep: 10)
+      rescue Exception # rubocop:disable Lint/RescueException
+        # Cleanup is non-critical; swallow all errors (including AgentInterrupted)
+        # so that the session file is always saved successfully
+      end
 
       filepath
     end