openclacky 1.5.11 → 1.5.13

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

@@ -67,7 +67,7 @@ module Clacky
         send_text("[USER] #{content}")
       end
 
-      def show_assistant_message(content, files:, interim: false)
+      def show_assistant_message(content, files:, interim: false, created_at: nil)
         if interim
           # Intermediate narration before a tool call. Suppressed unless
           # tool-process messages are enabled; flush pending previews first
@@ -95,7 +95,20 @@ module Clacky
       end
 
       def show_tool_call(name, args)
-        # Suppress — too noisy for IM
+        # ask_user is the one tool that must reach the user: the agent stops and
+        # waits for an answer, so swallowing it leaves the chat silently stuck.
+        # Sent unconditionally — it is a question, not process noise, so the
+        # process-messages toggle must not gate it.
+        if Clacky::Tools::AskUser.feedback_tool?(name)
+          args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+          questions = Clacky::Tools::AskUser.normalize_questions(args_data)
+          return if questions.empty?
+
+          context = args_data.is_a?(Hash) ? (args_data[:context] || args_data["context"]).to_s : ""
+          flush_buffer
+          send_text(Clacky::Tools::AskUser.render_text(questions, context))
+          return
+        end
       end
 
       def show_tool_result(result)
@@ -136,7 +149,7 @@ module Clacky
         # Suppress
       end
 
-      def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil)
+      def show_complete(iterations:, cost:, duration: nil, cache_stats: nil, awaiting_user_feedback: false, cost_source: nil, task_id: nil)
         flush_buffer
         return unless status_messages?
 

data/lib/clacky/server/dir_picker.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Clacky
+  module Server
+    # Directory-picker quick-access places + WSL/Windows drive detection.
+    # Extracted from HttpServer to keep the path/place helpers cohesive.
+    module DirPicker
+      # Windows "special" folders under C:\Users that aren't real user profiles.
+      WINDOWS_PROFILE_DIRS = ["Public", "Default", "Default User", "All Users"].freeze
+
+      # Sidebar quick-access favorites for the directory picker (Finder-style).
+      # Translated client-side via `id`. On WSL every favorite targets the
+      # Windows profile (/mnt/<drive>/Users/<name>/...) so they match where a
+      # Windows browser actually saves files; elsewhere they stay under Dir.home.
+      private def dir_picker_places
+        home = Dir.home
+        win_home = wsl_windows_home
+        places = []
+
+        [["home", win_home || home],
+         ["desktop",   File.join(win_home || home, "Desktop")],
+         ["downloads", File.join(win_home || home, "Downloads")],
+         ["documents", File.join(win_home || home, "Documents")]].each do |id, path|
+          places << { id: id, path: path, kind: "favorite" } if Dir.exist?(path)
+        end
+
+        places.concat(dir_picker_drives)
+        places
+      end
+
+      # Drive letters exposed to the picker so Windows users can reach D:/E:/…
+      # directly. Under WSL these are the /mnt/<drive> mounts; on native
+      # Windows the actual drive letters. Empty on macOS/Linux.
+      private def dir_picker_drives
+        if wsl?
+          mounts = "/mnt"
+          return [] unless Dir.exist?(mounts)
+
+          drives = []
+          Dir.children(mounts).sort.each do |drive|
+            next unless drive.match?(/\A[a-zA-Z]\z/)
+            path = File.join(mounts, drive)
+            next unless Dir.exist?(path)
+            drives << { id: "drive_#{drive.downcase}", path: path, letter: drive.upcase, kind: "drive" }
+          end
+          drives
+        elsif Gem.win_platform?
+          drives = []
+          ("A".."Z").each do |letter|
+            path = "#{letter}:/"
+            next unless Dir.exist?(path)
+            drives << { id: "drive_#{letter.downcase}", path: path, letter: letter, kind: "drive" }
+          end
+          drives
+        else
+          []
+        end
+      end
+
+      # True when running inside Windows Subsystem for Linux.
+      private def wsl?
+        return true if ENV["WSL_DISTRO_NAME"]
+        return true if File.exist?("/proc/sys/fs/binfmt_misc/WSLInterop")
+        version = begin
+          File.read("/proc/version")
+        rescue StandardError
+          ""
+        end
+        version.downcase.include?("microsoft")
+      end
+
+      # Best-effort path to the Windows user profile under WSL, or nil when it
+      # can't be determined (then callers fall back to Dir.home). Scans every
+      # mounted drive's Users dir instead of assuming the system drive is C:.
+      # Username sources are tried most-trusted first:
+      #   1. WINDOWS_USERNAME / USERNAME env (explicitly set or WSLENV-forwarded)
+      #   2. the live Windows %USERNAME%, read via cmd.exe interop
+      #   3. USER (the WSL Linux username, which usually matches the Windows one)
+      #   4. the first non-system profile dir found (last-resort guess)
+      private def wsl_windows_home
+        return nil unless wsl?
+
+        roots = wsl_windows_users_roots
+        wsl_profile_for(roots, ENV["WINDOWS_USERNAME"]) ||
+          wsl_profile_for(roots, ENV["USERNAME"]) ||
+          wsl_profile_for(roots, wsl_windows_username) ||
+          wsl_profile_for(roots, ENV["USER"]) ||
+          wsl_first_user_profile(roots)
+      end
+
+      # The first mounted profile dir named exactly `username`, or nil. WSL
+      # never inherits Windows env vars by default, which is why `username`
+      # may also come from cmd.exe interop rather than ENV.
+      private def wsl_profile_for(roots, username)
+        return nil if username.nil? || username.empty?
+
+        roots.each do |root|
+          candidate = File.join(root, username)
+          return candidate if Dir.exist?(candidate)
+        end
+        nil
+      end
+
+      # Last-resort guess: the first non-system profile dir under any mounted
+      # Users root. Filesystem enumeration order is arbitrary, so on
+      # multi-profile machines this may pick an inactive profile — every
+      # username source in wsl_windows_home exists to keep this unreached.
+      private def wsl_first_user_profile(roots)
+        roots.each do |root|
+          profiles = Dir.children(root).select do |name|
+            full = File.join(root, name)
+            File.directory?(full) &&
+              !WINDOWS_PROFILE_DIRS.include?(name) &&
+              !name.start_with?(".")
+          end
+          return File.join(root, profiles.first) if profiles.any?
+        end
+        nil
+      end
+
+      # The live Windows-side %USERNAME%, read via cmd.exe interop. Returns
+      # nil when interop is disabled or cmd.exe is unreachable; callers must
+      # still validate against the mounted Users directory. Cached —
+      # including failures — because interop availability doesn't change
+      # within a process and the spawn otherwise costs 100ms+ on every
+      # directory listing.
+      private def wsl_windows_username
+        return @wsl_windows_username if defined?(@wsl_windows_username)
+
+        @wsl_windows_username = begin
+          require "open3"
+          out, _err, status = Open3.capture3("cmd.exe", "/c", "echo %USERNAME%", binmode: true)
+          status.success? ? out.lines.first&.strip : nil
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Every mounted drive that exposes a Windows Users directory, e.g.
+      # /mnt/c/Users and /mnt/d/Users.
+      private def wsl_windows_users_roots
+        mounts = "/mnt"
+        return [] unless Dir.exist?(mounts)
+
+        roots = []
+        Dir.children(mounts).each do |drive|
+          root = File.join(mounts, drive, "Users")
+          roots << root if Dir.exist?(root)
+        end
+        roots
+      end
+    end
+  end
+end

data/lib/clacky/server/git_panel.rb

@@ -7,8 +7,8 @@ module Clacky
     # Read-mostly git operations scoped to a session's working directory, backing
     # the official "git" WebUI panel. Commands run with explicit argv (no shell),
     # so user-supplied values (paths, messages) cannot inject. Write operations
-    # are limited to a guarded `commit`; history-rewriting / remote-mutating
-    # commands are never exposed here.
+    # are limited to a guarded `commit` and a single-file `restore`;
+    # history-rewriting / remote-mutating commands are never exposed here.
     module GitPanel
       module_function
 
@@ -56,14 +56,24 @@ module Clacky
         { branch: branch, ahead: ahead, behind: behind, files: files }
       end
 
-      # Unified diff. `file` (optional, relative) limits to one path; omitted =
-      # whole working tree (tracked changes). `--` guards path from being read
-      # as an option.
+      # Unified diff for one file, or the whole tree when `file` is nil.
+      # Baseline is HEAD, not the index, so changes the agent staged with
+      # `git add` still show up. Untracked files have no baseline at all, so
+      # they diff against /dev/null via --no-index (rendered as pure
+      # additions); the trailing `--` keeps a leading-dash filename from
+      # being read as an option in that mode too.
       def diff(dir, file: nil)
-        args = ["diff"]
-        args += ["--", file] if file && !file.empty?
-        out, _err, _ok = git(dir, *args)
-        out
+        if file && !file.empty?
+          others, _e, _ok = git(dir, "ls-files", "--others", "--exclude-standard", "--", file)
+          if others.strip.empty?
+            out, _e, _ok = git(dir, "diff", "HEAD", "--", file)
+          else
+            out, _e, _ok = git(dir, "diff", "--no-index", "--", "/dev/null", file)
+          end
+          out
+        else
+          git(dir, "diff", "HEAD")[0]
+        end
       end
 
       # Recent commits: [{ hash:, short:, author:, date:, subject: }].
@@ -92,6 +102,48 @@ module Clacky
         end
       end
 
+      # Discard uncommitted changes to one file and return it to its HEAD
+      # state (same baseline the diff API uses, so "what you saw is what you
+      # lose"). Files that never existed in HEAD (staged-new or untracked)
+      # have no earlier version, so they are removed instead. argv-only and
+      # guarded against path traversal; history rewriting and remote-mutating
+      # commands remain out of bounds.
+      def restore(dir, file:)
+        path = file.to_s.strip
+        return { ok: false, error: "file is required" } if path.empty?
+        return { ok: false, error: "invalid path" } if invalid_path?(path)
+
+        head_tree, _e, _ok = git(dir, "ls-tree", "HEAD", "--", path)
+        if head_tree.include?("\t#{path}")
+          _o, err, ok = git(dir, "checkout", "HEAD", "--", path)
+          return ok ? { ok: true } : { ok: false, error: "git checkout failed: #{err.strip}" }
+        end
+
+        in_index, _e, idx_ok = git(dir, "ls-files", "--", path)
+        if idx_ok && !in_index.strip.empty?
+          _o, err, ok = git(dir, "rm", "-f", "--", path)
+          return ok ? { ok: true } : { ok: false, error: "git rm failed: #{err.strip}" }
+        end
+
+        target = File.expand_path(path, dir.to_s)
+        root = File.expand_path(dir.to_s)
+        return { ok: false, error: "invalid path" } unless target.start_with?(root + File::SEPARATOR)
+
+        begin
+          File.delete(target)
+          { ok: true }
+        rescue Errno::ENOENT
+          { ok: true }
+        rescue StandardError => e
+          { ok: false, error: e.message }
+        end
+      end
+
+      # Relative repo paths only: no absolute paths, no traversal segments.
+      def invalid_path?(path)
+        path.start_with?("/") || path.split("/").include?("..")
+      end
+
       # Stage `files` (relative paths) and commit with `message`. Returns
       # { ok:, error?:, hash? }. Refuses empty message / empty file set. Uses
       # argv so paths/message cannot inject; no --no-verify, no amend.