openclacky 1.5.19 → 1.5.21

data/lib/clacky/server/pid_files.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require_relative "../agent_config"
+
+module Clacky
+  module Server
+    # Shared directory policy for master lifecycle and CLI discovery.
+    module PidFiles
+      module_function
+
+      def directory
+        override = ENV["CLACKY_PID_DIR"]
+        configured = if override && !override.strip.empty?
+                       override
+                     else
+                       AgentConfig.load.pid_dir
+                     end
+        return Dir.tmpdir if configured.nil? || configured.strip.empty?
+
+        File.expand_path(configured)
+      end
+    end
+  end
+end

data/lib/clacky/server/server_master.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "socket"
-require "tmpdir"
+require_relative "pid_files"
 require_relative "../banner"
 require_relative "../version"
 require_relative "../agent_config"
@@ -248,13 +248,19 @@ module Clacky
       end
 
       def pid_file_path
-        File.join(Dir.tmpdir, "clacky-master-#{@port}.pid")
+        File.join(pid_directory, "clacky-master-#{@port}.pid")
       end
 
       def write_pid_file
+        FileUtils.mkdir_p(pid_directory)
         File.write(pid_file_path, Process.pid.to_s)
       end
 
+      # Keep cleanup tied to the directory used at startup, even if config changes.
+      private def pid_directory
+        @pid_directory ||= PidFiles.directory
+      end
+
       def remove_pid_file
         # A replacement may already own the port after this master was stopped.
         if File.exist?(pid_file_path) && File.read(pid_file_path).strip == Process.pid.to_s
@@ -318,7 +324,7 @@ module Clacky
       end
 
       private def kill_master_on_port(port)
-        path = File.join(Dir.tmpdir, "clacky-master-#{port}.pid")
+        path = File.join(pid_directory, "clacky-master-#{port}.pid")
         return unless File.exist?(path)
 
         pid = File.read(path).strip.to_i

data/lib/clacky/server/session_registry.rb

@@ -194,7 +194,8 @@ module Clacky
       #   profile: "general"|"coding"|nil
       #            nil = no agent_profile filter
       #   limit:   max sessions to return (applies to NON-PINNED only; see below)
-      #   before:  ISO8601 cursor — only sessions with created_at < before
+      #   before, before_id: cursor — only sessions sorting after (before, before_id)
+      #             in the newest-first order; take it from a row's `cursor`
       #             (also applies to NON-PINNED only; pinned items are a separate
       #             logical section, they should never be paginated away)
       #   include_pinned: when true (default), all matching pinned sessions are
@@ -204,11 +205,16 @@ module Clacky
       #             an old session always see it at the top of the sidebar,
       #             even if many newer sessions exist.
       #
+      #   archived:  false (default) → archived sessions are excluded from the
+      #             result; true → ONLY archived sessions are returned. The two
+      #             sets are disjoint, so every other caller keeps seeing exactly
+      #             the sessions it saw before archiving existed. nil → no filter.
+      #
       # Ordering of the returned array:
       #   [ ...all_pinned_matching (newest-first), ...non_pinned (newest-first, limited) ]
       #
       # source and profile are orthogonal — either can be nil independently.
-      def list(limit: nil, before: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true, project_id: nil, exclude_project: false)
+      def list(limit: nil, before: nil, before_id: nil, q: nil, q_scope: "name", date: nil, type: nil, exclude_type: nil, include_pinned: true, project_id: nil, exclude_project: false, archived: false)
         return [] unless @session_manager
 
         live = @mutex.synchronize do
@@ -222,6 +228,7 @@ module Clacky
             model: model_info&.dig(:model), model_id: model_info&.dig(:id), name: live_name,
             total_tasks: s[:agent]&.total_tasks, total_cost: s[:agent]&.total_cost,
             cost_source: live_cost_source,
+            permission_mode: s[:agent]&.permission_mode,
             reasoning_effort: s[:agent]&.reasoning_effort,
             latest_latency: s[:agent]&.latest_latency,
             card_model: model_info&.dig(:card_model),
@@ -233,6 +240,8 @@ module Clacky
 
         all = @session_manager.all_sessions  # already sorted newest-first
 
+        all = all.select { |s| archived ? s[:archived_at].to_s != "" : s[:archived_at].to_s == "" } unless archived.nil?
+
         # ── type filter (replaces old source/profile split) ──────────────────
         # type=coding  → agent_profile == "coding"
         # type=manual/cron/channel/setup → source match (profile=general implied)
@@ -290,9 +299,11 @@ module Clacky
         pinned, non_pinned = all.partition { |s| s[:pinned] }
 
         # `before` cursor ONLY applies to non-pinned (paginated) sessions.
-        # Cursor field must match the sort key in all_sessions (updated_at,
-        # falling back to created_at for legacy rows).
-        non_pinned = non_pinned.select { |s| (s[:updated_at] || s[:created_at] || "") < before } if before
+        # Cursor must match the sort key in all_sessions; the id breaks same-second ties.
+        if before
+          boundary = [before, before_id.to_s]
+          non_pinned = non_pinned.select { |s| (sort_key(s) <=> boundary) < 0 }
+        end
         non_pinned = non_pinned.first(limit) if limit
 
         # Pinned section: only included on the first page (before == nil) so
@@ -336,6 +347,7 @@ module Clacky
             model: model_info&.dig(:model), model_id: model_info&.dig(:id),
             name: live_name, total_tasks: s[:agent]&.total_tasks,
             total_cost: s[:agent]&.total_cost, cost_source: s[:agent]&.cost_source,
+            permission_mode: s[:agent]&.permission_mode,
             reasoning_effort: s[:agent]&.reasoning_effort,
             latest_latency: s[:agent]&.latest_latency,
             card_model: model_info&.dig(:card_model),
@@ -354,6 +366,10 @@ module Clacky
       # Merge a single disk-side session hash with the corresponding live
       # in-memory agent fields (may be nil) into the row shape the frontend
       # consumes.
+      private def sort_key(s)
+        [s[:updated_at] || s[:created_at] || "", s[:session_id].to_s]
+      end
+
       private def build_enriched_row(s, ls)
         id = s[:session_id]
         {
@@ -366,6 +382,7 @@ module Clacky
           raw_message:   ls&.dig(:raw_message),
           model:         ls&.dig(:model),
           model_id:      ls&.dig(:model_id),
+          permission_mode: ls&.dig(:permission_mode) || s.dig(:config, :permission_mode_override) || "confirm_all",
           card_model:    ls&.dig(:card_model),
           sub_model:     ls&.dig(:sub_model),
           sub_model_options: ls&.dig(:sub_model_options) || [],
@@ -384,9 +401,12 @@ module Clacky
           latest_latency: ls&.dig(:latest_latency),
           reasoning_effort: ls&.dig(:reasoning_effort) || s.dig(:config, :reasoning_effort),
           pinned:        s[:pinned] || false,
+          archived_at:   s[:archived_at],
           channel_info:  s[:channel_info],
           project_id:    s[:project_id],
           todos:         ls&.dig(:todos) || s[:todos] || [],
+          # Rows report live activity in updated_at; paging needs the on-disk sort key.
+          cursor:        sort_key(s).then { |at, sid| { before: at, before_id: sid } },
         }
       end
 
@@ -414,10 +434,13 @@ module Clacky
       public
 
       # Count + latest updated_at for sessions of a given source, excluding
-      # those assigned to a project (they show in the project section instead).
+      # those assigned to a project (they show in the project section instead)
+      # and archived ones (they show in the archive view instead).
       def group_stats(source)
         return { count: 0, latest_updated_at: nil } unless @session_manager
-        group_all = @session_manager.all_sessions.select { |s| s_source(s) == source && s[:project_id].to_s.strip == "" }
+        group_all = @session_manager.all_sessions.select {
+          |s| s_source(s) == source && s[:project_id].to_s.strip == "" && s[:archived_at].to_s == ""
+        }
         latest = group_all.map { |s| s[:updated_at] || s[:created_at] }.compact.max
         { count: group_all.size, latest_updated_at: latest }
       end
@@ -427,6 +450,13 @@ module Clacky
         SessionManager::GROUPED_SOURCES.to_h { |source| [source, group_stats(source)] }
       end
 
+      # How many sessions the archive holds. The archive page keeps only one
+      # page of rows in the browser, so its "delete all" confirmation takes the
+      # size from here — a header-only scan, unlike `list`.
+      def archived_count
+        @session_manager ? @session_manager.archived_count : 0
+      end
+
       # Delete a session from registry (and interrupt its thread).
       def delete(session_id)
         @mutex.synchronize do

data/lib/clacky/server/web_ui_controller.rb

@@ -68,6 +68,71 @@ module Clacky
         end
       end
 
+      # Use the same contract as the CLI. The server owns the deadline;
+      # typing cancels automatic continuation but keeps the answer wait alive.
+      def request_feedback_with_countdown(seconds: 20)
+        pending = { id: @feedback_request_id || SecureRandom.uuid, cond: ConditionVariable.new,
+                    deadline_ms: (Time.now.to_f * 1000).to_i + seconds * 1000 }
+        pending[:seconds] = seconds
+        pending[:deadline] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
+        @mutex.synchronize do
+          pending[:manual] = @feedback_permission_mode == :confirm_all
+          @pending_feedback = pending
+        end
+        emit("feedback_countdown", request_id: pending[:id], deadline_ms: pending[:manual] ? nil : pending[:deadline_ms])
+        @mutex.synchronize do
+          until pending[:result]
+            remaining = pending[:deadline] - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            if !pending[:manual] && remaining <= 0
+              pending[:result] = :timeout
+            else
+              pending[:cond].wait(@mutex, pending[:manual] ? nil : remaining)
+            end
+          end
+          pending[:result]
+        end
+      ensure
+        cleared = @mutex.synchronize do
+          if pending && @pending_feedback.equal?(pending)
+            @pending_feedback = nil
+            true
+          end
+        end
+        if cleared
+          emit("feedback_countdown", request_id: pending[:id], resolved: true,
+               resolution: pending[:result] || :cancelled)
+        end
+      end
+
+      def update_permission_mode(mode)
+        countdown = @mutex.synchronize do
+          @feedback_permission_mode = mode.to_sym
+          pending = @pending_feedback
+          if pending && !pending[:result]
+            if mode.to_sym == :auto_approve && pending[:manual]
+              pending[:deadline] = Process.clock_gettime(Process::CLOCK_MONOTONIC) + pending[:seconds]
+              pending[:deadline_ms] = (Time.now.to_f * 1000).to_i + pending[:seconds] * 1000
+            end
+            pending[:manual] = mode.to_sym != :auto_approve
+            pending[:cond].signal
+            { request_id: pending[:id],
+              deadline_ms: pending[:manual] ? nil : pending[:deadline_ms] }
+          end
+        end
+        emit("feedback_countdown", **countdown) if countdown
+      end
+
+      def intervene_feedback(request_id)
+        @mutex.synchronize do
+          pending = @pending_feedback
+          return false unless pending && pending[:id] == request_id && !pending[:result]
+          pending[:result] = :intervened
+          pending[:cond].signal
+          emit("feedback_countdown", request_id: pending[:id], deadline_ms: nil)
+          true
+        end
+      end
+
       # === Output display ===
 
       def show_user_message(content, created_at: nil, files: [], source: :web, skill_command: nil, skill_command_display: nil, steering: false, references: [])
@@ -129,7 +194,9 @@ module Clacky
           context   = args_data.is_a?(Hash) ? (args_data[:context] || args_data["context"]).to_s : ""
           first     = questions.first || {}
 
+          @feedback_request_id = Clacky::Tools::AskUser.fetch_key(args_data, :request_id)
           emit("request_feedback",
+               request_id: @feedback_request_id,
                question: first[:question].to_s,
                context: context,
                options: first[:options] || [],
@@ -336,6 +403,11 @@ module Clacky
       # The frontend's appendToolStdout will attach to the last visible .tool-item
       # even when _liveLastToolItem is null (after the tab re-loaded).
       def replay_live_state
+        countdown = @mutex.synchronize do
+          pending = @pending_feedback
+          pending ? { request_id: pending[:id], deadline_ms: pending[:manual] ? nil : pending[:deadline_ms] } : { resolved: true }
+        end
+        emit("feedback_countdown", **countdown)
         return unless @live_progress_state
 
         # Replay complete progress state (not just message).

data/lib/clacky/session_manager.rb

@@ -216,7 +216,7 @@ module Clacky
     def all_sessions(current_dir: nil, limit: nil)
       sessions = Dir.glob(File.join(@sessions_dir, "*.json")).filter_map do |filepath|
         load_session_file(filepath)
-      end.sort_by { |s| s[:updated_at] || s[:created_at] || "" }.reverse
+      end.sort_by { |s| [s[:updated_at] || s[:created_at] || "", s[:session_id].to_s] }.reverse
 
       if current_dir
         current_sessions = sessions.select { |s| s[:working_dir] == current_dir }
@@ -363,7 +363,10 @@ module Clacky
       metas = files.filter_map { |f| m = load_session_metadata(f); m && m.merge(_path: f) }
                    .sort_by { |s| s[:updated_at] || s[:created_at] || "" }.reverse
 
-      non_pinned = metas.reject { |s| s[:pinned] }
+      # Archived sessions are user-curated, so they are exempt from the rolling
+      # cap exactly like pinned ones — an archive that silently empties itself
+      # would be worse than no archive at all.
+      non_pinned = metas.reject { |s| s[:pinned] || s[:archived_at].to_s != "" }
 
       groups = non_pinned.group_by { |s| group_key_for(s) }
 
@@ -433,6 +436,12 @@ module Clacky
       Clacky::Tools::TrashManager.permanent_delete_trash_session(session_id, sessions_dir: @sessions_dir)
     end
 
+    # Permanently delete exactly these sessions from the trash. Returns the count deleted.
+    def permanent_delete_trash_sessions(session_ids)
+      require_relative "tools/trash_manager"
+      Clacky::Tools::TrashManager.empty_trash_sessions(sessions_dir: @sessions_dir, ids: session_ids)
+    end
+
     # Keep file-trash on the same rolling window as sessions-trash.
     def cleanup_file_trash(days: 8)
       require_relative "tools/trash_manager"
@@ -547,10 +556,11 @@ module Clacky
     # Read only the small scalar header of a session file without parsing the
     # (potentially multi-MB) messages / time_machine payload. Session JSON is
     # written with a stable field order, so the fields we care about here
-    # (session_id, pinned, created_at, updated_at, source) always sit in the
-    # first few hundred bytes, before any large array/object. `project_id`
-    # lives much later and is intentionally NOT read — callers that need it
-    # fall back to load_session_file for the rare candidate that requires it.
+    # (session_id, pinned, archived_at, created_at, updated_at, source) always
+    # sit in the first few hundred bytes, before any large array/object.
+    # `project_id` lives much later and is intentionally NOT read — callers
+    # that need it fall back to load_session_file for the rare candidate that
+    # requires it.
     #
     # Returns a Hash with symbol keys, or nil if the header can't be read.
     METADATA_HEADER_BYTES = 16 * 1024
@@ -564,6 +574,7 @@ module Clacky
       {
         session_id: sid,
         pinned:     head[/"pinned"\s*:\s*(true|false)/, 1] == "true",
+        archived_at: head[/"archived_at"\s*:\s*"([^"]*)"/, 1],
         created_at: head[/"created_at"\s*:\s*"([^"]*)"/, 1],
         updated_at: head[/"updated_at"\s*:\s*"([^"]*)"/, 1],
         source:     head[/"source"\s*:\s*"([^"]*)"/, 1]
@@ -572,6 +583,17 @@ module Clacky
       nil
     end
 
+    # How many sessions sit in the archive. The WebUI offers "delete all" on
+    # that page, so it needs the size of the whole archive rather than the page
+    # it happens to have loaded — and a header-only read keeps the cost at one
+    # small read per file.
+    def archived_count
+      Dir.glob(File.join(@sessions_dir, "*.json")).count do |filepath|
+        meta = load_session_metadata(filepath)
+        meta && meta[:archived_at].to_s != ""
+      end
+    end
+
     # Remove Time Machine snapshots that no longer belong to any known session.
     # Snapshots are keyed by full session_id; session files are named by the
     # 8-char id prefix, so a snapshot dir is an orphan when its prefix matches

data/lib/clacky/skill.rb

@@ -319,7 +319,7 @@ module Clacky
           > should either:
           >
           > 1. Ask the user to start the server in another terminal: `clacky server`
-          >    (then retry — the CLI auto-detects it via `/tmp/clacky-master-*.pid`), or
+          >    (then retry — the CLI auto-detects it via `clacky-master-*.pid` in the configured PID directory), or
           > 2. If the task can be completed without the server API, skip those steps
           >    and tell the user which parts require the server.
           >

data/lib/clacky/tools/ask_user.rb

@@ -110,7 +110,7 @@ module Clacky
         recommended = recommended.to_i if recommended.is_a?(Numeric) || recommended.to_s =~ /\A-?\d+\z/
         recommended = nil unless recommended.is_a?(Integer) && recommended >= 0 && recommended < options.size
 
-        {
+        normalized = {
           question: text,
           description: fetch_key(item, :description).to_s.strip,
           options: options,
@@ -119,6 +119,9 @@ module Clacky
           allow_free_text: options.empty? || truthy?(fetch_key(item, :allow_free_text)),
           recommended: recommended
         }
+        metadata = fetch_key(item, :metadata)
+        normalized[:metadata] = metadata if metadata.is_a?(Hash)
+        normalized
       end
 
       def self.fetch_key(hash, key)

data/lib/clacky/tools/base.rb

@@ -14,8 +14,9 @@ module Clacky
         attr_accessor :receives_tool_call_id
       end
 
-      # Host agent, injected at registration for extension tools so they can
-      # reach its public API (fan_out_labeled, fork_subagent, skill_loader).
+      # Host agent, injected at registration for extension tools and for built-ins
+      # that need its public API (config, fan_out_labeled, fork_subagent,
+      # skill_loader).
       attr_accessor :agent
 
       def name

data/lib/clacky/tools/browser.rb

@@ -543,12 +543,21 @@ module Clacky
         # Save original (full-resolution) PNG to disk before any downscaling
         original_path = save_screenshot_to_disk(image_block["data"], suffix: "original")
 
+        config = screenshot_config
+        limit = config["screenshot_max_base64_bytes"]
+        max_base64_bytes = limit.is_a?(Integer) && limit.positive? ? limit : SCREENSHOT_MAX_BASE64_BYTES
         image_data = png_downscale_base64(image_block["data"], SCREENSHOT_MAX_WIDTH)
+        if image_data.bytesize > max_base64_bytes
+          image_data = Clacky::Utils::FileProcessor.quantize_png_base64(image_data)
+        end
 
-        if image_data.bytesize > SCREENSHOT_MAX_BASE64_BYTES
+        if image_data.bytesize > max_base64_bytes
           size_kb = image_data.bytesize / 1024
+          saved   = original_path ? " The full-resolution file is saved at #{original_path}." : ""
           return { action: "screenshot", success: false, profile: "user",
-                   output: "Screenshot too large after resize (#{size_kb}KB). Use action=snapshot instead." }
+                   original_path: original_path,
+                   output: "Screenshot still too large after compression (#{size_kb}KB).#{saved} " \
+                           "Use action=snapshot instead." }
         end
 
         # Save compressed (800px) PNG for AI reference
@@ -560,6 +569,13 @@ module Clacky
           output: "Screenshot captured." }
       end
 
+      private def screenshot_config
+        config = YAMLCompat.safe_load(File.read(BROWSER_CONFIG_PATH), permitted_classes: [Date, Time, Symbol])
+        config.is_a?(Hash) ? config : {}
+      rescue StandardError
+        {}
+      end
+
       private def png_downscale_base64(b64, max_width)
         Clacky::Utils::FileProcessor.downscale_image_base64(
           b64, "image/png", max_width: max_width

data/lib/clacky/tools/file_reader.rb

@@ -46,7 +46,7 @@ module Clacky
       MAX_CONTENT_CHARS = 60_000
 
       # Maximum characters per line (prevent single huge lines from bloating tokens)
-      MAX_LINE_CHARS = 1000
+      MAX_LINE_CHARS = 8_000
 
       def execute(path:, max_lines: 1000, start_line: nil, end_line: nil, working_dir: nil, image_max_width: nil)
         # Expand path relative to working_dir when provided

data/lib/clacky/tools/terminal/session_manager.rb

@@ -43,7 +43,9 @@ module Clacky
           :read_offset,     # Integer, bytes already returned by previous read calls
           :mutex,           # per-session mutex for PTY writes
           :resource_group,   # Optional cgroup for task limits and OOM attribution
+          :script_paths,    # Internal script paths for cleanup and output masking
           :shell_name,      # "zsh" | "bash" | "sh" — informs marker syntax & rc reload
+          :echo_head,       # String, last `{ CMD` line written; strips its wrapped echo
           keyword_init: true
         )
 
@@ -77,6 +79,7 @@ module Clacky
                 read_offset: 0,
                 mutex: Mutex.new,
                 resource_group: resource_group,
+                script_paths: [],
                 shell_name: shell_name
               )
               @sessions[session.id] = session
@@ -116,7 +119,21 @@ module Clacky
           # Forget a session (after it has been killed/exited).  Does NOT kill
           # the process — callers should kill first.
           def forget(id)
-            @mutex.synchronize { @sessions.delete(id) }
+            session = @mutex.synchronize { @sessions.delete(id) }
+            cleanup_scripts(session) if session
+          end
+
+          # Cleanup must never replace the command's result with an unlink error.
+          def cleanup_scripts(session)
+            # The reader may clean up before buffered output is packaged.
+            # Preserve paths so error messages can still mask internal filenames.
+            Array(session.script_paths).each do |path|
+              begin
+                File.unlink(path)
+              rescue SystemCallError
+                # Best effort; retain the path for a later cleanup attempt.
+              end
+            end
           end
 
           # Refresh status of one session in-place (mutex-held).
@@ -188,6 +205,7 @@ module Clacky
               s.log_io&.close rescue nil
               s.writer&.close rescue nil
               s.reader&.close rescue nil
+              cleanup_scripts(s)
             end
           end