openclacky 0.9.7 → 0.9.9

data/lib/clacky/server/http_server.rb

@@ -31,7 +31,12 @@ module Clacky
       def show_user_message(content, created_at: nil, files: [])
         ev = { type: "history_user_message", session_id: @session_id, content: content }
         ev[:created_at] = created_at if created_at
-        ev[:files] = files if files && !files.empty?
+        rendered = Array(files).filter_map do |f|
+          url  = f[:data_url] || f["data_url"]
+          name = f[:name]     || f["name"]
+          url || (name ? "pdf:#{name}" : nil)
+        end
+        ev[:images] = rendered unless rendered.empty?
         @events << ev
       end
 
@@ -127,7 +132,7 @@ module Clacky
         - 将大目标拆解为可执行的小步骤
       MD
 
-      def initialize(host: "127.0.0.1", port: 7070, agent_config:, client_factory:, brand_test: false)
+      def initialize(host: "127.0.0.1", port: 7070, agent_config:, client_factory:, brand_test: false, sessions_dir: nil)
         @host           = host
         @port           = port
         @agent_config   = agent_config
@@ -137,16 +142,16 @@ module Clacky
         # so api_restart can re-exec the correct binary even if cwd changes later.
         @restart_script = File.expand_path($0)
         @restart_argv   = ARGV.dup
-        @registry        = SessionRegistry.new
-        @session_manager = Clacky::SessionManager.new
+        @session_manager = Clacky::SessionManager.new(sessions_dir: sessions_dir)
+        @registry        = SessionRegistry.new(
+          session_manager:  @session_manager,
+          session_restorer: method(:build_session_from_data)
+        )
         @ws_clients      = {}  # session_id => [WebSocketConnection, ...]
         @ws_mutex        = Mutex.new
         # Version cache: { latest: "x.y.z", checked_at: Time }
         @version_cache   = nil
         @version_mutex   = Mutex.new
-        # Version cache: { latest: "x.y.z", checked_at: Time }
-        @version_cache   = nil
-        @version_mutex   = Mutex.new
         @scheduler       = Scheduler.new(
           session_registry: @registry,
           session_builder:  method(:build_session)
@@ -158,6 +163,7 @@ module Clacky
           interrupt_session: method(:interrupt_session),
           channel_config:    Clacky::ChannelConfig.load
         )
+        @browser_manager = Clacky::BrowserManager.instance
         @skill_loader    = Clacky::SkillLoader.new(working_dir: nil, brand_config: Clacky::BrandConfig.load)
       end
 
@@ -171,6 +177,14 @@ module Clacky
         File.write(pid_file, Process.pid.to_s)
         at_exit { File.delete(pid_file) if File.exist?(pid_file) }
 
+        # Expose server address and brand name to all child processes (skill scripts, shell commands, etc.)
+        # so they can call back into the server without hardcoding the port,
+        # and use the correct product name without re-reading brand.yml.
+        ENV["CLACKY_SERVER_PORT"]  = @port.to_s
+        ENV["CLACKY_SERVER_HOST"]  = (@host == "0.0.0.0" ? "127.0.0.1" : @host)
+        product_name = Clacky::BrandConfig.load.product_name
+        ENV["CLACKY_PRODUCT_NAME"] = (product_name.nil? || product_name.strip.empty?) ? "OpenClacky" : product_name
+
         # Override WEBrick's built-in signal traps via StartCallback,
         # which fires after WEBrick sets its own INT/TERM handlers.
         # This ensures Ctrl-C always exits immediately.
@@ -243,6 +257,9 @@ module Clacky
         # Start IM channel adapters (non-blocking — each platform runs in its own thread)
         @channel_manager.start
 
+        # Start browser MCP daemon if browser.yml is configured (non-blocking)
+        @browser_manager.start
+
         server.start
       end
 
@@ -261,7 +278,7 @@ module Clacky
         end
 
         case [method, path]
-        when ["GET",    "/api/sessions"]      then api_list_sessions(res)
+        when ["GET",    "/api/sessions"]      then api_list_sessions(req, res)
         when ["POST",   "/api/sessions"]      then api_create_session(req, res)
         when ["GET",    "/api/schedules"]     then api_list_schedules(res)
         when ["POST",   "/api/schedules"]     then api_create_schedule(req, res)
@@ -274,6 +291,10 @@ module Clacky
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
         when ["GET",    "/api/providers"]     then api_list_providers(res)
         when ["GET",    "/api/onboard/status"]    then api_onboard_status(res)
+        when ["GET",    "/api/browser/status"]    then api_browser_status(res)
+        when ["POST",   "/api/browser/configure"]  then api_browser_configure(req, res)
+        when ["POST",   "/api/browser/reload"]    then api_browser_reload(res)
+        when ["POST",   "/api/browser/toggle"]    then api_browser_toggle(res)
         when ["POST",   "/api/onboard/complete"]  then api_onboard_complete(req, res)
         when ["POST",   "/api/onboard/skip-soul"] then api_onboard_skip_soul(req, res)
         when ["GET",    "/api/store/skills"]          then api_store_skills(res)
@@ -282,6 +303,7 @@ module Clacky
         when ["GET",    "/api/brand/skills"]      then api_brand_skills(res)
         when ["GET",    "/api/brand"]             then api_brand_info(res)
         when ["GET",    "/api/channels"]          then api_list_channels(res)
+        when ["POST",   "/api/tool/browser"]      then api_tool_browser(req, res)
         when ["POST",   "/api/upload"]            then api_upload_file(req, res)
         when ["GET",    "/api/version"]           then api_get_version(res)
         when ["POST",   "/api/version/upgrade"]   then api_upgrade_version(req, res)
@@ -337,8 +359,17 @@ module Clacky
 
       # ── REST API ──────────────────────────────────────────────────────────────
 
-      def api_list_sessions(res)
-        json_response(res, 200, { sessions: @registry.list })
+      def api_list_sessions(req, res)
+        query   = URI.decode_www_form(req.query_string.to_s).to_h
+        limit   = [query["limit"].to_i.then { |n| n > 0 ? n : 10 }, 50].min
+        before  = query["before"].to_s.strip.then { |v| v.empty? ? nil : v }
+        source  = query["source"].to_s.strip.then { |v| v.empty? ? nil : v }
+        profile = query["profile"].to_s.strip.then { |v| v.empty? ? nil : v }
+        # Fetch one extra to detect has_more without a separate count query
+        sessions = @registry.list(limit: limit + 1, before: before, source: source, profile: profile)
+        has_more = sessions.size > limit
+        sessions = sessions.first(limit)
+        json_response(res, 200, { sessions: sessions, has_more: has_more })
       end
 
       def api_create_session(req, res)
@@ -346,11 +377,20 @@ module Clacky
         name = body["name"]
         return json_response(res, 400, { error: "name is required" }) if name.nil? || name.strip.empty?
 
+        # Optional agent_profile; defaults to "general" if omitted or invalid
+        profile = body["agent_profile"].to_s.strip
+        profile = "general" if profile.empty?
+
+        # Optional source; defaults to :manual. Accept "system" for skill-launched sessions
+        # (e.g. /onboard, /browser-setup, /channel-setup).
+        raw_source = body["source"].to_s.strip
+        source = %w[manual cron channel setup].include?(raw_source) ? raw_source.to_sym : :manual
+
         working_dir = default_working_dir
         FileUtils.mkdir_p(working_dir)
 
-        session_id = build_session(name: name, working_dir: working_dir)
-        json_response(res, 201, { session: @registry.list.find { |s| s[:id] == session_id } })
+        session_id = build_session(name: name, working_dir: working_dir, profile: profile, source: source)
+        json_response(res, 201, { session: @registry.session_summary(session_id) })
       end
 
       # Auto-restore persisted sessions (or create a fresh default) when the server starts.
@@ -363,15 +403,13 @@ module Clacky
       def create_default_session
         return unless @agent_config.models_configured?
 
-        working_dir = default_working_dir
-        FileUtils.mkdir_p(working_dir) unless Dir.exist?(working_dir)
-
-        # Restore the most recent 5 sessions for this working directory
-        sessions_data = @session_manager.latest_n_for_directory(working_dir, 5)
+        # Restore up to 5 sessions per source type from disk into the registry.
+        @registry.restore_from_disk(n: 5)
 
-        if sessions_data.any?
-          sessions_data.each { |session_data| build_session_from_data(session_data) }
-        else
+        # If nothing was restored (no persisted sessions), create a fresh default.
+        unless @registry.list(limit: 1).any?
+          working_dir = default_working_dir
+          FileUtils.mkdir_p(working_dir) unless Dir.exist?(working_dir)
           build_session(name: "Session 1", working_dir: working_dir)
         end
       end
@@ -390,12 +428,50 @@ module Clacky
         end
       end
 
+      # GET /api/browser/status
+      # Returns real daemon liveness from BrowserManager (not just yml read).
+      def api_browser_status(res)
+        json_response(res, 200, @browser_manager.status)
+      end
+
+      # POST /api/browser/configure
+      # Called by browser-setup skill to write browser.yml and hot-reload the daemon.
+      # Body: { chrome_version: "146" }
+      def api_browser_configure(req, res)
+        body          = JSON.parse(req.body.to_s) rescue {}
+        chrome_version = body["chrome_version"].to_s.strip
+        return json_response(res, 422, { ok: false, error: "chrome_version is required" }) if chrome_version.empty?
+
+        @browser_manager.configure(chrome_version: chrome_version)
+        json_response(res, 200, { ok: true })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # POST /api/browser/reload
+      # Called by browser-setup skill after writing browser.yml.
+      # Hot-reloads the MCP daemon with the new configuration.
+      def api_browser_reload(res)
+        @browser_manager.reload
+        json_response(res, 200, { ok: true })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
+      # POST /api/browser/toggle
+      def api_browser_toggle(res)
+        enabled = @browser_manager.toggle
+        json_response(res, 200, { ok: true, enabled: enabled })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       # POST /api/onboard/complete
       # Called after key setup is done (soul_setup is optional/skipped).
       # Creates the default session if none exists yet, returns it.
       def api_onboard_complete(req, res)
-        create_default_session if @registry.list.empty?
-        first_session = @registry.list.first
+        create_default_session if @registry.list(limit: 1).empty?
+        first_session = @registry.list(limit: 1).first
         json_response(res, 200, { ok: true, session: first_session })
       end
 
@@ -674,8 +750,17 @@ module Clacky
         argv   = @restart_argv
         Thread.new do
           sleep 0.5  # Let WEBrick flush the HTTP response
-          Clacky::Logger.info("[Restart] exec: #{RbConfig.ruby} #{script} #{argv.join(' ')}")
-          exec(RbConfig.ruby, script, *argv)
+
+          # Use login shell to re-exec so rbenv/mise shims resolve the newly installed gem version.
+          # Direct `exec(RbConfig.ruby, script, *argv)` would reuse the old Ruby interpreter path
+          # and miss gem updates installed under a different Ruby version managed by rbenv/mise.
+          shell      = ENV["SHELL"].to_s
+          shell      = "/bin/bash" if shell.empty?
+          cmd_parts  = [Shellwords.escape(script), *argv.map { |a| Shellwords.escape(a) }]
+          cmd_string = cmd_parts.join(" ")
+
+          Clacky::Logger.info("[Restart] exec: #{shell} -l -c #{cmd_string}")
+          exec(shell, "-l", "-c", cmd_string)
         end
       end
 
@@ -753,6 +838,28 @@ module Clacky
 
       # GET /api/channels
       # Returns current config and running status for all supported platforms.
+      # POST /api/tool/browser
+      # Executes a browser tool action via the shared BrowserManager daemon.
+      # Used by skill scripts (e.g. feishu_setup.rb) to reuse the server's
+      # existing Chrome connection without spawning a second MCP daemon.
+      #
+      # Request body: JSON with same params as the browser tool
+      #   { "action": "snapshot", "interactive": true, ... }
+      #
+      # Response: JSON result from the browser tool
+      def api_tool_browser(req, res)
+        params = parse_json_body(req)
+        action = params["action"]
+        return json_response(res, 400, { error: "action is required" }) if action.nil? || action.empty?
+
+        tool   = Clacky::Tools::Browser.new
+        result = tool.execute(**params.transform_keys(&:to_sym))
+
+        json_response(res, 200, result)
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
+
       def api_list_channels(res)
         config   = Clacky::ChannelConfig.load
         running  = @channel_manager.running_platforms
@@ -782,18 +889,12 @@ module Clacky
           return
         end
 
-        ref = Clacky::Utils::FileProcessor.process(
+        saved = Clacky::Utils::FileProcessor.save(
           body:     upload[:data],
           filename: upload[:filename].to_s
         )
 
-        json_response(res, 200, {
-          ok:           true,
-          name:         ref.name,
-          type:         ref.type.to_s,
-          path:         ref.original_path,
-          preview_path: ref.preview_path
-        })
+        json_response(res, 200, { ok: true, name: saved[:name], path: saved[:path] })
       rescue => e
         json_response(res, 500, { ok: false, error: e.message })
       end
@@ -808,6 +909,20 @@ module Clacky
 
         fields = body.transform_keys(&:to_sym).reject { |k, _| k == :platform }
         fields = fields.transform_values { |v| v.is_a?(String) ? v.strip : v }
+
+        # Validate credentials against live API before persisting.
+        # Merge with existing config so partial updates (e.g. allowed_users only) still validate correctly.
+        klass = Clacky::Channel::Adapters.find(platform)
+        if klass && klass.respond_to?(:test_connection)
+          existing = config.platform_config(platform) || {}
+          merged   = existing.merge(fields)
+          result   = klass.test_connection(merged)
+          unless result[:ok]
+            json_response(res, 422, { ok: false, error: result[:error] || "Credential validation failed" })
+            return
+          end
+        end
+
         config.set_platform(platform, **fields)
         config.save
 
@@ -868,6 +983,13 @@ module Clacky
           {
             bot_id: raw["bot_id"] || ""
           }
+        when :weixin
+          {
+            base_url:      raw["base_url"] || Clacky::Channel::Adapters::Weixin::ApiClient::DEFAULT_BASE_URL,
+            allowed_users: raw["allowed_users"] || [],
+            # Indicate whether a token is present (never expose the token itself)
+            has_token:     !raw["token"].to_s.strip.empty?
+          }
         else
           {}
         end
@@ -1039,8 +1161,7 @@ module Clacky
           # after the client has subscribed and is ready to receive broadcasts.
           @registry.update(session_id, pending_task: prompt, pending_working_dir: working_dir)
 
-          session = @registry.list.find { |s| s[:id] == session_id }
-          json_response(res, 202, { ok: true, session: session })
+          json_response(res, 202, { ok: true, session: @registry.session_summary(session_id) })
         rescue => e
           json_response(res, 422, { error: e.message })
         end
@@ -1071,6 +1192,10 @@ module Clacky
       # filtered by the session's agent profile. Used by the frontend slash-command
       # autocomplete so only skills valid for the current profile are suggested.
       def api_session_skills(session_id, res)
+        unless @registry.ensure(session_id)
+          json_response(res, 404, { error: "Session not found" })
+          return
+        end
         session = @registry.get(session_id)
         unless session
           json_response(res, 404, { error: "Session not found" })
@@ -1089,10 +1214,16 @@ module Clacky
         skills = agent.skill_loader.user_invocable_skills
         skills = skills.select { |s| s.allowed_for_agent?(profile.name) } if profile
 
+        loader      = agent.skill_loader
+        loaded_from = loader.loaded_from
+
         skill_data = skills.map do |skill|
+          source_type = loaded_from[skill.identifier]
           {
             name:        skill.identifier,
-            description: skill.description || skill.context_description
+            description: skill.description || skill.context_description,
+            encrypted:   skill.encrypted?,
+            source_type: source_type
           }
         end
 
@@ -1326,7 +1457,7 @@ module Clacky
       # Replays conversation history for a session via the agent's replay_history method.
       # Returns a list of UI events (same format as WS events) for the frontend to render.
       def api_session_messages(session_id, req, res)
-        unless @registry.exist?(session_id)
+        unless @registry.ensure(session_id)
           return json_response(res, 404, { error: "Session not found" })
         end
 
@@ -1355,7 +1486,7 @@ module Clacky
         new_name = body["name"].to_s.strip
 
         return json_response(res, 400, { error: "name is required" }) if new_name.empty?
-        return json_response(res, 404, { error: "Session not found" }) unless @registry.exist?(session_id)
+        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] }
@@ -1369,6 +1500,8 @@ module Clacky
 
       def api_delete_session(session_id, res)
         if @registry.delete(session_id)
+          # Also remove the persisted session file from disk
+          @session_manager.delete(session_id)
           # Notify connected clients the session is gone
           broadcast(session_id, { type: "session_deleted", session_id: session_id })
           unsubscribe_all(session_id)
@@ -1442,7 +1575,7 @@ module Clacky
         case type
         when "subscribe"
           session_id = msg["session_id"]
-          if @registry.exist?(session_id)
+          if @registry.ensure(session_id)
             conn.session_id = session_id
             subscribe(session_id, conn)
             conn.send_json(type: "subscribed", session_id: session_id)
@@ -1467,7 +1600,24 @@ module Clacky
           interrupt_session(session_id)
 
         when "list_sessions"
-          conn.send_json(type: "session_list", sessions: @registry.list)
+          # Initial load: 5 per bucket so all tabs/sections get their first page.
+          # General area tabs: manual / cron / channel / setup — filtered by source.
+          # Coding section: profile=coding — source is irrelevant (no source filter).
+          # has_more_by_source drives independent load-more buttons on the frontend.
+          buckets = {
+            "manual"  => { source: "manual",  profile: "general" },
+            "cron"    => { source: "cron",    profile: "general" },
+            "channel" => { source: "channel", profile: "general" },
+            "setup"   => { source: "setup",   profile: "general" },
+            "coding"  => { profile: "coding" },
+          }
+          by_bucket = buckets.each_with_object({}) do |(key, params), h|
+            page = @registry.list(limit: 6, **params)  # +1 to detect has_more
+            h[key] = { sessions: page.first(5), has_more: page.size > 5 }
+          end
+          all_sessions = by_bucket.values.flat_map { |v| v[:sessions] }.uniq { |s| s[:id] }
+          has_more_map = by_bucket.transform_values { |v| v[:has_more] }
+          conn.send_json(type: "session_list", sessions: all_sessions, has_more_by_source: has_more_map)
 
         when "run_task"
           # Client sends this after subscribing to guarantee it's ready to receive
@@ -1513,6 +1663,11 @@ module Clacky
           broadcast(session_id, { type: "session_renamed", session_id: session_id, name: auto_name })
         end
 
+        # Broadcast user message through web_ui so channel subscribers (飞书/企微) receive it.
+        web_ui = nil
+        @registry.with_session(session_id) { |s| web_ui = s[:ui] }
+        web_ui&.show_user_message(content, source: :web)
+
         # File references are now handled inside agent.run — injected as a system_injected
         # message after the user message, so replay_history skips them automatically.
         run_agent_task(session_id, agent) { agent.run(content, files: files) }
@@ -1580,7 +1735,10 @@ module Clacky
         rescue => e
           @registry.update(session_id, status: :error, error: e.message)
           broadcast_session_update(session_id)
-          broadcast(session_id, { type: "error", session_id: session_id, message: e.message })
+          # 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)
           @session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
         end
         @registry.with_session(session_id) { |s| s[:thread] = thread }
@@ -1623,7 +1781,7 @@ module Clacky
       # Broadcast a session_update event to all clients so they can patch their
       # local session list without needing a full session_list refresh.
       def broadcast_session_update(session_id)
-        session = @registry.list.find { |s| s[:id] == session_id }
+        session = @registry.list(limit: 200).find { |s| s[:id] == session_id }
         return unless session
 
         broadcast_all(type: "session_update", session: session)
@@ -1631,7 +1789,6 @@ module Clacky
 
       # ── Helpers ───────────────────────────────────────────────────────────────
 
-      # Default working directory for new sessions.
       def default_working_dir
         File.expand_path("~/clacky_workspace")
       end
@@ -1643,7 +1800,7 @@ module Clacky
       # @param working_dir [String] working directory for the agent
       # @param permission_mode [Symbol] :confirm_all (default, human present) or
       #   :auto_approve (unattended — suppresses request_user_feedback waits)
-      def build_session(name:, working_dir:, permission_mode: :confirm_all, profile: "general")
+      def build_session(name:, working_dir:, permission_mode: :confirm_all, profile: "general", source: :manual)
         session_id = Clacky::SessionManager.generate_id
         @registry.create(session_id: session_id)
 
@@ -1653,7 +1810,7 @@ module Clacky
         broadcaster = method(:broadcast)
         ui = WebUIController.new(session_id, broadcaster)
         agent = Clacky::Agent.new(client, config, working_dir: working_dir, ui: ui, profile: profile,
-                                  session_id: session_id)
+                                  session_id: session_id, source: source)
         agent.rename(name) unless name.nil? || name.empty?
         idle_timer = build_idle_timer(session_id, agent)
 
@@ -1663,6 +1820,10 @@ module Clacky
           s[:idle_timer] = idle_timer
         end
 
+        # Persist an initial snapshot so the session is immediately visible in registry.list
+        # (which reads from disk). Without this, new sessions only appear after their first task.
+        @session_manager.save(agent.to_session_data)
+
         session_id
       end
 
@@ -1683,7 +1844,11 @@ module Clacky
         config.permission_mode = permission_mode
         broadcaster = method(:broadcast)
         ui = WebUIController.new(original_id, broadcaster)
-        agent = Clacky::Agent.from_session(client, config, session_data, ui: ui, profile: "general")
+        # Restore the agent profile from the persisted session; fall back to "general"
+        # for sessions saved before the agent_profile field was introduced.
+        profile = session_data[:agent_profile].to_s
+        profile = "general" if profile.empty?
+        agent = Clacky::Agent.from_session(client, config, session_data, ui: ui, profile: profile)
         idle_timer = build_idle_timer(original_id, agent)
 
         @registry.with_session(original_id) do |s|

data/lib/clacky/server/scheduler.rb

@@ -168,7 +168,7 @@ module Clacky
         FileUtils.mkdir_p(working_dir)
 
         # Scheduled tasks run unattended — use auto_approve so request_user_feedback doesn't block.
-        session_id = @session_builder.call(name: name, working_dir: working_dir, permission_mode: :auto_approve)
+        session_id = @session_builder.call(name: name, working_dir: working_dir, permission_mode: :auto_approve, source: :cron)
 
         Clacky::Logger.info("scheduler_task_fired", task: task_name, session: session_id)