openclacky 1.2.18 → 1.3.0

data/lib/clacky/server/backup_manager.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+require "yaml"
+require "time"
+
+module Clacky
+  module Server
+    # Backs up the user's ~/.clacky directory to a safe location.
+    #
+    # Design notes:
+    #   * Regenerable caches/logs are always excluded to keep archives small.
+    #   * On WSL, the default destination is a Windows drive (/mnt/c|d|e) so
+    #     backups survive a WSL distro reset.
+    #   * Session history (sessions/ + snapshots/) is optional — it is the
+    #     bulk of the data and the user may not want it in every archive.
+    #   * Config lives in ~/.clacky/backup.yml, separate from config.yml so
+    #     it never mixes with API keys.
+    class BackupManager
+      CLACKY_DIR  = File.expand_path("~/.clacky")
+      CONFIG_FILE = File.join(CLACKY_DIR, "backup.yml")
+
+      # Always excluded — regenerable or disposable.
+      ALWAYS_EXCLUDE = %w[
+        ocr_cache parsers parsers-1 logger safety_logs trash .DS_Store backup.yml
+      ].freeze
+
+      # Excluded unless the user opts into a full backup.
+      HEAVY_EXCLUDE = %w[sessions snapshots].freeze
+
+      DEFAULT_CONFIG = {
+        "enabled"          => false,
+        "cron"             => "0 3 * * *",
+        "dest_dir"         => nil,
+        "keep"             => 7,
+        "include_sessions" => true,
+        "last_run_at"      => nil,
+        "last_status"      => nil,
+        "last_error"       => nil,
+        "last_archive"     => nil
+      }.freeze
+
+      class << self
+        def config
+          DEFAULT_CONFIG.merge(load_raw)
+        end
+
+        def update_config(enabled: nil, cron: nil, dest_dir: nil, keep: nil, include_sessions: nil)
+          cfg = config
+          cfg["enabled"]          = !!enabled            unless enabled.nil?
+          cfg["cron"]             = cron.to_s            unless cron.nil?
+          cfg["dest_dir"]         = normalize_dest(dest_dir) unless dest_dir.nil?
+          cfg["keep"]             = [keep.to_i, 1].max   unless keep.nil?
+          cfg["include_sessions"] = !!include_sessions   unless include_sessions.nil?
+          save_raw(cfg)
+          cfg
+        end
+
+        # Run a backup now. Returns a hash describing the result.
+        def run!
+          cfg     = config
+          dest    = resolve_dest(cfg["dest_dir"])
+          FileUtils.mkdir_p(dest)
+
+          stamp   = Time.now.strftime("%Y%m%d-%H%M%S")
+          archive = File.join(dest, "clacky-backup-#{stamp}.tar.gz")
+          excludes = ALWAYS_EXCLUDE.dup
+          excludes.concat(HEAVY_EXCLUDE) unless cfg["include_sessions"]
+
+          ok = build_archive(archive, excludes)
+          unless ok && File.exist?(archive)
+            record_result(cfg, status: "error", error: "tar failed", archive: nil)
+            raise "Backup failed: tar did not produce an archive"
+          end
+
+          prune(dest, cfg["keep"])
+          record_result(cfg, status: "success", error: nil, archive: archive)
+
+          { archive: archive, size: File.size(archive), dest_dir: dest }
+        rescue => e
+          Clacky::Logger.error("backup_run_error", error: e) if defined?(Clacky::Logger)
+          record_result(config, status: "error", error: e.message, archive: nil)
+          raise
+        end
+
+        # Build a one-off archive for direct download (not written to dest_dir,
+        # not pruned, not recorded). Always includes session history so the
+        # downloaded file is a complete snapshot. Caller is responsible for
+        # deleting the returned temp file after streaming it.
+        def build_download!
+          stamp    = Time.now.strftime("%Y%m%d-%H%M%S")
+          filename = "clacky-backup-#{stamp}.tar.gz"
+          archive  = File.join(Dir.tmpdir, filename)
+
+          ok = build_archive(archive, ALWAYS_EXCLUDE.dup)
+          unless ok && File.exist?(archive)
+            FileUtils.rm_f(archive)
+            raise "Backup failed: tar did not produce an archive"
+          end
+
+          { path: archive, filename: filename, size: File.size(archive) }
+        end
+
+        # List existing backup archives at the resolved destination.
+        def list
+          dest = resolve_dest(config["dest_dir"])
+          return [] unless Dir.exist?(dest)
+
+          Dir.glob(File.join(dest, "clacky-backup-*.tar.gz")).map do |path|
+            {
+              "name"       => File.basename(path),
+              "path"       => path,
+              "size"       => File.size(path),
+              "created_at" => File.mtime(path).iso8601
+            }
+          end.sort_by { |b| b["created_at"] }.reverse
+        end
+
+        # Resolved destination + whether we're on WSL (for UI display).
+        def status
+          dest = resolve_dest(config["dest_dir"])
+          {
+            "config"   => config,
+            "dest_dir" => dest,
+            "is_wsl"   => wsl?,
+            "backups"  => list
+          }
+        end
+
+        def wsl?
+          @wsl ||= begin
+            File.exist?("/proc/version") &&
+              File.read("/proc/version").match?(/microsoft|wsl/i)
+          rescue StandardError
+            false
+          end
+        end
+
+        # ── internals ──────────────────────────────────────────────────────
+
+        # Where archives go when the user hasn't set an explicit dest_dir.
+        def default_dest
+          if wsl?
+            %w[d c e].each do |drive|
+              mount = "/mnt/#{drive}"
+              return File.join(mount, "clacky_backups") if Dir.exist?(mount) && File.writable?(mount)
+            end
+          end
+          File.expand_path("~/clacky_backups")
+        end
+
+        private def resolve_dest(dir)
+          d = dir.to_s.strip
+          d.empty? ? default_dest : File.expand_path(d)
+        end
+
+        private def normalize_dest(dir)
+          d = dir.to_s.strip
+          d.empty? ? nil : d
+        end
+
+        private def build_archive(archive, excludes)
+          args = ["tar", "-czf", archive, "-C", CLACKY_DIR]
+          excludes.each { |e| args << "--exclude=./#{e}" }
+          args << "."
+          system(*args)
+        end
+
+        private def prune(dest, keep)
+          keep = [keep.to_i, 1].max
+          all  = Dir.glob(File.join(dest, "clacky-backup-*.tar.gz")).sort_by { |f| File.mtime(f) }.reverse
+          all.drop(keep).each { |f| FileUtils.rm_f(f) }
+        end
+
+        private def record_result(cfg, status:, error:, archive:)
+          cfg = cfg.dup
+          cfg["last_run_at"]  = Time.now.iso8601
+          cfg["last_status"]  = status
+          cfg["last_error"]   = error
+          cfg["last_archive"] = archive ? File.basename(archive) : cfg["last_archive"]
+          save_raw(cfg)
+        end
+
+        private def load_raw
+          return {} unless File.exist?(CONFIG_FILE)
+
+          YAMLCompat.load_file(CONFIG_FILE) || {}
+        rescue StandardError
+          {}
+        end
+
+        private def save_raw(cfg)
+          FileUtils.mkdir_p(CLACKY_DIR)
+          File.write(CONFIG_FILE, YAML.dump(cfg))
+        end
+      end
+    end
+  end
+end

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

@@ -178,10 +178,18 @@ module Clacky
                 return
               end
               unless Array(event[:mentioned_open_ids]).include?(bot_id)
-                user_name = @bot.fetch_user_name(event[:user_id])
-                @on_message&.call(event.merge(observe_only: true, user_name: user_name))
                 return
               end
+
+              begin
+                history = @bot.fetch_chat_history(event[:chat_id], limit: Bot::GROUP_HISTORY_LIMIT)
+                Clacky::Logger.info("[feishu] fetch_chat_history chat=#{event[:chat_id]} got #{history.size} messages")
+                event = event.merge(group_history: history) unless history.empty?
+              rescue FeishuScopeError => e
+                scopes_text = e.required_scopes.any? ? e.required_scopes.join(", ") : Bot::SCOPE_GROUP_MSG
+                scope_hint = e.auth_url ? "The developer can grant access here: #{e.auth_url}" : "Please enable the following scopes for this app in Feishu Open Platform: #{scopes_text}"
+                event = event.merge(text: "#{event[:text]}\n\n[System Notice] This app is missing the scope to read group message history. #{scope_hint} Do NOT mention this proactively — only inform the user if they ask about chat history or context.")
+              end
             end
 
             allowed_users = @config[:allowed_users]

data/lib/clacky/server/channel/adapters/feishu/bot.rb

@@ -3,6 +3,7 @@
 require "faraday"
 require "faraday/multipart"
 require "json"
+require "uri"
 
 module Clacky
   module Channel
@@ -30,11 +31,27 @@ module Clacky
           end
         end
 
+        # Raised when any API call fails with 99991672 (missing app scope).
+        # The admin needs to open auth_url to grant the required permissions.
+        class FeishuScopeError < StandardError
+          attr_reader :auth_url, :required_scopes
+
+          def initialize(auth_url, required_scopes: [])
+            @auth_url = auth_url
+            @required_scopes = required_scopes
+            super("App is missing required API scope")
+          end
+        end
+
         # Feishu Bot API client.
         # Handles authentication, message sending, and API calls.
         class Bot
           API_TIMEOUT = 10
           DOWNLOAD_TIMEOUT = 60
+          ERR_SCOPE_MISSING = 99991672
+          ERR_SCOPE_MISSING_2 = 230027
+          GROUP_HISTORY_LIMIT = 15
+          SCOPE_GROUP_MSG = "im:message.group_msg"
 
           def initialize(app_id:, app_secret:, domain: DEFAULT_DOMAIN)
             @app_id = app_id
@@ -42,7 +59,7 @@ module Clacky
             @domain = domain
             @token_cache = nil
             @token_expires_at = nil
-            @user_name_cache = {}
+
           end
 
           # Send plain text message
@@ -227,7 +244,50 @@ module Clacky
             }.join
           end
 
-          # Get this bot's own open_id (cached, fetched lazily on first use).
+          # Fetch recent messages from a chat via the message list API.
+          # Returns an array of { user_id, text } hashes, oldest first.
+          # @param chat_id [String]
+          # @param limit [Integer]
+          # @return [Array<Hash>]
+          def fetch_chat_history(chat_id, limit: GROUP_HISTORY_LIMIT)
+            response = get("/open-apis/im/v1/messages", params: {
+              container_id_type: "chat",
+              container_id:      chat_id,
+              sort_type:         "ByCreateTimeDesc",
+              page_size:         limit
+            })
+            unless response["code"] == 0
+              code = response["code"].to_i
+              Clacky::Logger.warn("[feishu] fetch_chat_history failed code=#{code} msg=#{response["msg"]}, ext=#{response.dig("error", "message") || response["msg"]}")
+              if code == ERR_SCOPE_MISSING || code == ERR_SCOPE_MISSING_2
+                auth_url = response.dig("error", "permission_violations", 0, "attach_url") ||
+                           extract_url(response["msg"].to_s)
+                scopes = (response.dig("error", "permission_violations") || []).map { |v| v["subject"] }.compact
+                raise FeishuScopeError.new(auth_url, required_scopes: scopes)
+              end
+              return []
+            end
+
+            items = response.dig("data", "items") || []
+            Clacky::Logger.info("[feishu] fetch_chat_history chat=#{chat_id} api_items=#{items.size} first=#{items.first&.inspect}")
+            items.reverse.filter_map do |item|
+              content = begin
+                body = JSON.parse(item.dig("body", "content").to_s)
+                body["text"].to_s.gsub(/@_user_\S+\s?/, "").gsub(/@\S+\s?/, "").strip
+              rescue JSON::ParserError
+                nil
+              end
+              next if content.nil? || content.empty?
+
+              sender_id = item.dig("sender", "id").to_s
+              { user_id: sender_id, text: content }
+            end
+          rescue FeishuScopeError
+            raise
+          rescue => e
+            Clacky::Logger.warn("[feishu] fetch_chat_history failed: #{e.message}")
+            []
+          end
           # Used to detect @bot mentions in group chats.
           # @return [String, nil] bot open_id, or nil if the API call fails
           def bot_open_id
@@ -237,17 +297,6 @@ module Clacky
             nil
           end
 
-          def fetch_user_name(open_id)
-            return @user_name_cache[open_id] if @user_name_cache.key?(open_id)
-
-            name = get("/open-apis/contact/v3/users/#{open_id}", params: { user_id_type: "open_id" })
-                     .dig("data", "user", "name")
-            @user_name_cache[open_id] = name.to_s.strip.then { |n| n.empty? ? open_id : n }
-          rescue => e
-            Clacky::Logger.warn("[feishu] Failed to fetch user name for #{open_id}: #{e.message}")
-            @user_name_cache[open_id] = open_id
-          end
-
           # Get tenant access token (cached)
           # @return [String] Access token
           def tenant_access_token
@@ -450,16 +499,20 @@ module Clacky
 
             if code == 91403
               raise FeishuDocPermissionError, token
-            elsif code == 99991672
+            elsif code == ERR_SCOPE_MISSING
               # Extract auth URL from the error message if present
               auth_url = response.dig("error", "permission_violations", 0, "attach_url") ||
-                         response["msg"].to_s[/https:\/\/open\.feishu\.cn\/app\/[^\s"]+/]
+                         extract_url(response["msg"].to_s)
               raise FeishuDocScopeError.new(auth_url)
             else
               raise "Failed to fetch doc: code=#{code} msg=#{response["msg"]}"
             end
           end
 
+          private def extract_url(text)
+            text[URI::DEFAULT_PARSER.make_regexp(%w[https])]
+          end
+
           # Build Faraday connection
           # @return [Faraday::Connection]
           def build_connection

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative "channel_ui_controller"
-require_relative "group_message_buffer"
 
 module Clacky
   module Channel
@@ -28,14 +27,11 @@ module Clacky
       # @param run_agent_task     [Proc] (session_id, agent, &task) — from HttpServer
       # @param interrupt_session  [Proc] (session_id) — from HttpServer
       # @param channel_config     [Clacky::ChannelConfig]
-      # @param binding_mode       [:user | :chat | :chat_user] how to map IM identities to sessions.
-      #   :chat_user (default) — one session per (chat, user) pair. Most natural:
-      #                          private chat = that user's session; in a group each
-      #                          user has their own session; the same user across
-      #                          different groups keeps those contexts separate.
-      #   :chat                — one session per chat (all users in a group share it).
-      #   :user                — one session per user (merges DMs and all groups).
-      def initialize(session_registry:, session_builder:, run_agent_task:, interrupt_session:, channel_config:, binding_mode: :chat_user)
+      # @param binding_mode       [:chat | :chat_user | :user] how to map IM identities to sessions.
+      #   :chat (default)      — one session per chat (all users in a chat share it).
+      #   :chat_user           — one session per (chat, user) pair.
+      #   :user                — one session per user (merges all chats).
+      def initialize(session_registry:, session_builder:, run_agent_task:, interrupt_session:, channel_config:, binding_mode: :chat)
         @registry          = session_registry
         @session_builder   = session_builder
         @run_agent_task    = run_agent_task
@@ -46,8 +42,7 @@ module Clacky
         @adapter_threads   = []
         @running           = false
         @mutex             = Mutex.new
-        @session_counters  = Hash.new(0)  # platform => count, for short session names
-        @group_buffer      = GroupMessageBuffer.new
+        @session_counters  = Hash.new(0)
       end
 
       # Start all enabled adapters in background threads. Non-blocking.
@@ -82,15 +77,6 @@ module Clacky
         @mutex.synchronize { @adapters.map(&:platform_id) }
       end
 
-      # Return all buffered group chat messages for a given chat.
-      # @param chat_id [String]
-      # @return [Array<Hash>] each entry has :user_id, :user_name, :text
-      def group_history(chat_id)
-        @group_buffer.peek(chat_id).map do |e|
-          { user_id: e.user_id, user_name: e.user_name, text: e.text }
-        end
-      end
-
       # Proactively send a message to a user on the given platform.
       #
       # For Weixin (iLink protocol) a context_token is required for every outbound
@@ -244,7 +230,6 @@ module Clacky
 
       def route_message(adapter, event)
         if event[:observe_only]
-          @group_buffer.push(event[:chat_id], user_id: event[:user_id], user_name: event[:user_name], text: event[:text].to_s)
           return
         end
 
@@ -320,7 +305,7 @@ module Clacky
         # Prepend buffered group history so the agent knows what was discussed
         # before it was @-mentioned. Buffer is cleared atomically on take.
         # WebUI always receives the raw user text — context is agent-only.
-        prompt = build_prompt_with_context(event[:chat_id], text)
+        prompt = build_prompt_with_context(event, text)
 
         # Start typing keepalive BEFORE sending any message.
         # sendmessage cancels the typing indicator in WeChat protocol,
@@ -375,17 +360,28 @@ module Clacky
           else
             arg
           end
-          unless session_id && @registry.get(session_id)
+          unless session_id && @registry.ensure(session_id)
             adapter.send_text(chat_id, "Session not found. Use /list to see available sessions.")
             return
           end
 
           # Detach channel_ui from the old session's web_ui, reattach to the new one.
+          # Also clear the old session's persisted agent.channel_info if it still
+          # matches this key — keeping channel_keys and channel_info strictly in sync
+          # so resolve_session never sees two sessions claim the same key via different
+          # sources (see comment in resolve_session).
           old_session_id = resolve_session(event)
           channel_ui = old_session_id ? channel_ui_for_session(old_session_id) : nil
 
           if channel_ui
-            @registry.with_session(old_session_id) { |s| s[:ui]&.unsubscribe_channel(channel_ui); s.delete(:channel_ui) }
+            @registry.with_session(old_session_id) do |s|
+              s[:ui]&.unsubscribe_channel(channel_ui)
+              s.delete(:channel_ui)
+              if s[:agent]&.respond_to?(:channel_info=) && s[:agent].respond_to?(:channel_info) &&
+                 s[:agent].channel_info && channel_key_from_info(s[:agent].channel_info) == key
+                s[:agent].channel_info = nil
+              end
+            end
           else
             channel_ui = ChannelUIController.new(event, -> { adapter_for(event[:platform]) })
           end
@@ -412,7 +408,17 @@ module Clacky
           unbound = false
           @registry.list.each do |summary|
             @registry.with_session(summary[:id]) do |s|
-              unbound = true if s[:channel_keys]&.delete(key)
+              if s[:channel_keys]&.delete(key)
+                unbound = true
+                # Keep agent.channel_info in sync with channel_keys (see resolve_session).
+                # Without this, after process restart + eviction, the fallback path would
+                # silently re-bind this key back to the unbinded session via stale
+                # channel_info, defeating /unbind.
+                if s[:agent]&.respond_to?(:channel_info=) && s[:agent].respond_to?(:channel_info) &&
+                   s[:agent].channel_info && channel_key_from_info(s[:agent].channel_info) == key
+                  s[:agent].channel_info = nil
+                end
+              end
             end
           end
           adapter.send_text(chat_id, unbound ? "Unbound." : "No binding found.")
@@ -630,12 +636,20 @@ module Clacky
 
       def resolve_session(event)
         key = channel_key(event)
+
+        # Resolve order per session:
+        #   1. explicit in-memory channel_keys (set by /bind or auto_create_session)
+        #   2. fallback to persisted agent.channel_info for evicted channel sessions
+        #      (process restart with in-memory channel_keys lost)
+        #
+        # /bind and /unbind keep agent.channel_info strictly in sync with channel_keys
+        # (see handle_bind / handle_unbind), so the two sources never disagree on the
+        # same key for two different sessions — a single pass is sufficient.
         @registry.list.each do |summary|
           found = nil
           @registry.with_session(summary[:id]) { |s| found = s[:channel_keys]&.include?(key) }
           return summary[:id] if found
 
-          # Check evicted channel sessions via persisted channel_info
           next unless summary[:source] == "channel"
           next unless @registry.ensure(summary[:id])
           agent = nil
@@ -645,6 +659,7 @@ module Clacky
           bind_key_to_session(key, summary[:id])
           return summary[:id]
         end
+
         nil
       rescue StandardError => e
         Clacky::Logger.error("[ChannelManager] Session resolve failed: #{e.message}")
@@ -739,7 +754,7 @@ module Clacky
         case @binding_mode
         when :chat      then "#{platform}:chat:#{event[:chat_id]}"
         when :user      then "#{platform}:user:#{event[:user_id]}"
-        else # :chat_user (default)
+        else # :chat_user
           "#{platform}:chat:#{event[:chat_id]}:user:#{event[:user_id]}"
         end
       end
@@ -751,17 +766,16 @@ module Clacky
         case @binding_mode
         when :chat      then "#{platform}:chat:#{chat_id}"
         when :user      then "#{platform}:user:#{user_id}"
-        else # :chat_user (default)
+        else # :chat_user
           "#{platform}:chat:#{chat_id}:user:#{user_id}"
         end
       end
 
       private def extract_channel_info(event)
         {
-          platform:  event[:platform],
-          user_id:   event[:user_id],
-          user_name: event[:user_name],
-          chat_id:   event[:chat_id]
+          platform: event[:platform],
+          user_id:  event[:user_id],
+          chat_id:  event[:chat_id]
         }
       end
 
@@ -805,12 +819,16 @@ module Clacky
 
           key = channel_key_from_info(info)
 
-          event = { platform: info[:platform], chat_id: info[:chat_id] }
-          ensure_channel_ui_subscribed(summary[:id], event)
-
+          # Arbitrate first: skip duplicate keys before attaching any channel_ui.
+          # Attaching channel_ui to a loser session would leave an orphan in its
+          # web_ui subscriber list (it cannot be detached later), which a subsequent
+          # /bind onto that session would then double up — causing duplicate broadcasts.
           next unless bound_keys.add?(key)
           bind_key_to_session(key, summary[:id])
 
+          event = { platform: info[:platform], chat_id: info[:chat_id] }
+          ensure_channel_ui_subscribed(summary[:id], event)
+
           Clacky::Logger.info("[ChannelManager] Restored channel binding #{key} -> session #{summary[:id][0, 8]}")
           restored_count += 1
         end
@@ -823,23 +841,20 @@ module Clacky
         Clacky::Logger.warn("[ChannelManager] Error stopping #{adapter.platform_id}: #{e.message}")
       end
 
-      # Prepend recent group chat history to the user's message so the agent
-      # has context for questions like "what were we just discussing?".
-      # Returns the original text unchanged when there is no buffered history.
-      private def build_prompt_with_context(chat_id, text)
-        entries = @group_buffer.peek(chat_id, limit: GroupMessageBuffer::PROMPT_LIMIT)
-        return text if entries.empty?
-
-        total = @group_buffer.peek(chat_id).size
-        lines = entries.map { |e| "#{e.user_name || e.user_id}: #{e.text}" }.join("\n")
+      # Prepend sender identity and optional group chat history to the user's message.
+      # Returns the original text unchanged when there is no extra context.
+      private def build_prompt_with_context(event, text)
+        user_id = event[:user_id].to_s
+        sender  = user_id
 
-        partial = total > entries.size
-        header = partial ? "[Group chat partial history (latest #{entries.size} of #{total}, max buffer #{GroupMessageBuffer::MAX_MESSAGES} messages)]" : "[Group chat history (#{total} messages, max buffer #{GroupMessageBuffer::MAX_MESSAGES})]"
-        footer = if partial
-                   "[INSTRUCTION: If the above partial history is insufficient to answer, MUST web_fetch http://#{ENV["CLACKY_SERVER_HOST"]}:#{ENV["CLACKY_SERVER_PORT"]}/api/channels/group_history/#{chat_id} for full context.]"
-                 end
+        history = event[:group_history]
+        if history.nil? || history.empty?
+          return "[Sender: #{sender}]\n#{text}"
+        end
 
-        [header, lines, footer, "---", text].compact.join("\n")
+        lines  = history.map { |e| "#{e[:user_id]}: #{e[:text]}" }.join("\n")
+        header = "[Group chat history (#{history.size} messages)]"
+        [header, lines, "---", "[Sender: #{sender}]", text].join("\n")
       end
     end
   end