openclacky 1.2.17 → 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