openclacky 1.5.13 → 1.5.15

data/lib/clacky/server/preview.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "socket"
+require "timeout"
+
+module Clacky
+  module Server
+    # Preview panel routes: static workspace-file serving
+    # (/preview/s/<session>/<path>) and localhost dev-server proxying
+    # (/preview/p/<port>/<path>). Mixed into HttpServer so the route table
+    # (send(:serve_preview, ...)) dispatches into it unchanged.
+    module Preview
+      # MIME types served by the /preview/s/<session>/<path> route. Anything
+      # not listed falls back to a download (application/octet-stream) so an
+      # AI-generated page's sibling files can never execute as HTML.
+      PREVIEW_CONTENT_TYPES = {
+        ".html"  => "text/html; charset=utf-8",
+        ".htm"   => "text/html; charset=utf-8",
+        ".css"   => "text/css; charset=utf-8",
+        ".js"    => "text/javascript; charset=utf-8",
+        ".mjs"   => "text/javascript; charset=utf-8",
+        ".json"  => "application/json; charset=utf-8",
+        ".map"   => "application/json; charset=utf-8",
+        ".svg"   => "image/svg+xml",
+        ".png"   => "image/png",
+        ".jpg"   => "image/jpeg",
+        ".jpeg"  => "image/jpeg",
+        ".gif"   => "image/gif",
+        ".webp"  => "image/webp",
+        ".avif"  => "image/avif",
+        ".ico"   => "image/x-icon",
+        ".bmp"   => "image/bmp",
+        ".woff"  => "font/woff",
+        ".woff2" => "font/woff2",
+        ".ttf"   => "font/ttf",
+        ".otf"   => "font/otf",
+        ".eot"   => "application/vnd.ms-fontobject",
+        ".txt"   => "text/plain; charset=utf-8",
+        ".xml"   => "application/xml; charset=utf-8",
+        ".csv"   => "text/csv; charset=utf-8",
+        ".wasm"  => "application/wasm",
+        ".mp4"   => "video/mp4",
+        ".webm"  => "video/webm",
+        ".mp3"   => "audio/mpeg",
+        ".wav"   => "audio/wav",
+        ".ogg"   => "audio/ogg"
+      }.freeze
+
+      # Injected into preview HTML responses. The preview iframe is sandboxed
+      # without allow-same-origin, so the host page cannot read its location
+      # (and the iframe's src property does not follow internal navigations).
+      # Each served page therefore announces its own URL to the parent.
+      PREVIEW_NAV_REPORT = '<script>(function(){try{parent.postMessage({__clackyPreview:1,href:location.href},"*")}catch(e){}})()</script>'
+
+      # Headers dropped when proxying a localhost dev server through the
+      # preview panel. X-Frame-Options is what blocks the sandboxed iframe;
+      # hop-by-hop headers and Set-Cookie must not cross the proxy boundary
+      # (WEBrick recomputes the former, cookies would leak the upstream's
+      # domain into ours). CSP frame-ancestors is handled separately so the
+      # rest of the policy survives.
+      PROXY_SKIP_HEADERS = %w[
+        x-frame-options
+        transfer-encoding
+        content-length
+        connection
+        keep-alive
+        proxy-authenticate
+        proxy-authorization
+        te
+        trailer
+        upgrade
+        set-cookie
+      ].freeze
+
+      # Connection-stage failures when dialing the localhost dev server. The
+      # proxy retries the next loopback stack on these and answers 502 only
+      # when both stacks fail.
+      PROXY_CONNECT_ERRORS = [
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::EHOSTUNREACH,
+        Net::OpenTimeout,
+        SocketError
+      ].freeze
+
+      private def preview_not_found(res)
+        res.status = 404
+        res.body   = "not found"
+      end
+
+      private def preview_method_not_allowed(res)
+        res.status   = 405
+        res["Allow"] = "GET, HEAD"
+        res.body     = "method not allowed"
+      end
+
+      private def preview_invalid_port(res)
+        res.status = 400
+        res.body   = "invalid port"
+      end
+
+      private def preview_unreachable(res, port)
+        res.status = 502
+        res.body   = "cannot reach localhost:#{port}"
+      end
+
+      # GET /preview/s/<session_id>/<rel> — serve a workspace file for the
+      # preview panel. The session id resolves to that session's working_dir
+      # and rel must stay inside it. Directory requests fall back to
+      # index.html so the page's relative asset references keep resolving.
+      # Extensions missing from PREVIEW_CONTENT_TYPES download (octet-stream)
+      # instead of rendering, so a non-listed file can never execute as HTML.
+      private def serve_preview(req, res)
+        unless req.request_method == "GET" || req.request_method == "HEAD"
+          preview_method_not_allowed(res)
+          return
+        end
+
+        rest = preview_decode_path(req.path.delete_prefix("/preview/"))
+        sid, _, rel = rest.delete_prefix("s/").partition("/")
+
+        session     = sid.empty? ? nil : @session_manager.load(sid)
+        working_dir = session ? session[:working_dir].to_s : ""
+        if working_dir.empty?
+          preview_not_found(res)
+          return
+        end
+
+        root = File.expand_path(working_dir)
+        abs  = File.expand_path(File.join(root, rel))
+        unless abs == root || abs.start_with?(root + File::SEPARATOR)
+          preview_not_found(res)
+          return
+        end
+
+        serve_preview_file(req, res, abs)
+      end
+
+      # GET /preview/f/<absolute-path> — serve a local file outside the
+      # workspace, addressed by its absolute path (the panel maps file:// URLs
+      # here). Restricted to the user's home directory so it cannot read
+      # system files elsewhere.
+      private def serve_preview_local(req, res)
+        unless req.request_method == "GET" || req.request_method == "HEAD"
+          preview_method_not_allowed(res)
+          return
+        end
+
+        abs = preview_decode_path(req.path.delete_prefix("/preview/f"))
+        return preview_not_found(res) if abs.empty? || !abs.start_with?("/")
+
+        abs  = File.expand_path(abs)
+        home = File.expand_path(Dir.home)
+        unless abs == home || abs.start_with?(home + File::SEPARATOR)
+          preview_not_found(res)
+          return
+        end
+
+        serve_preview_file(req, res, abs)
+      end
+
+      # Shared tail for the file-serving routes: resolve a directory to its
+      # index.html, then stream the file with the MIME whitelist and the
+      # injected navigation reporter.
+      private def serve_preview_file(req, res, abs)
+        abs = File.join(abs, "index.html") if File.directory?(abs)
+        unless File.file?(abs)
+          preview_not_found(res)
+          return
+        end
+
+        res.status                      = 200
+        res["Content-Type"]             = PREVIEW_CONTENT_TYPES[File.extname(abs).downcase] || "application/octet-stream"
+        res["Cache-Control"]            = "no-store"
+        res["Pragma"]                   = "no-cache"
+        res["X-Content-Type-Options"]  = "nosniff"
+        if req.request_method == "HEAD"
+          res["Content-Length"] = File.size(abs).to_s
+          res.body = ""
+        else
+          body = preview_body(abs)
+          res["Content-Length"] = body.bytesize.to_s
+          res.body = body
+        end
+      end
+
+      # Injected right after <head> (falling back to <html>, <!DOCTYPE>, or
+      # the document start) so the reporter runs before page scripts while a
+      # leading <!DOCTYPE> stays first — prepending would flip the document
+      # into quirks mode.
+      private def preview_body(abs)
+        body = File.binread(abs)
+        return body unless (PREVIEW_CONTENT_TYPES[File.extname(abs).downcase] || "").start_with?("text/html")
+
+        html = body.force_encoding(Encoding::UTF_8)
+        if (m = html.match(/<head[^>]*>/i))
+          html[m.end(0), 0] = PREVIEW_NAV_REPORT
+        elsif (m = html.match(/<html[^>]*>/i))
+          html[m.end(0), 0] = PREVIEW_NAV_REPORT
+        elsif (m = html.match(/<!DOCTYPE[^>]*>/i))
+          html[m.end(0), 0] = PREVIEW_NAV_REPORT
+        else
+          html = PREVIEW_NAV_REPORT + html
+        end
+        html
+      end
+
+      # Decode %XX escapes in a preview path segment without treating "+" as
+      # space: "+" is a legal literal character in file names.
+      private def preview_decode_path(seg)
+        return seg unless seg.include?("%")
+
+        seg.gsub(/%([0-9A-Fa-f]{2})/) { |m| m[1, 2].to_i(16).chr }
+           .force_encoding(Encoding::UTF_8)
+      end
+
+      # GET /preview/p/<port>/<path> — proxy a localhost dev server through the
+      # preview panel. Rails/Next.js and friends ship X-Frame-Options / CSP
+      # frame-ancestors by default, which blocks a sandboxed iframe; the proxy
+      # strips those so the page renders. The host is restricted to the loopback
+      # interfaces (127.0.0.1 then ::1 — the port is the only variable), so this
+      # route can never be pointed at the public internet or another internal
+      # host — no SSRF.
+      private def serve_preview_proxy(req, res)
+        unless req.request_method == "GET" || req.request_method == "HEAD"
+          preview_method_not_allowed(res)
+          return
+        end
+
+        port_str, _, rel = req.path.delete_prefix("/preview/p/").partition("/")
+        unless port_str.match?(/\A\d+\z/)
+          preview_invalid_port(res)
+          return
+        end
+        port = port_str.to_i
+        if port < 1 || port > 65_535
+          preview_invalid_port(res)
+          return
+        end
+
+        target = "/" + rel
+        target += "?" + req.query_string if req.query_string && !req.query_string.empty?
+
+        klass = req.request_method == "HEAD" ? Net::HTTP::Head : Net::HTTP::Get
+
+        resp = nil
+        # Vite 5 binds only the IPv6 loopback (::1) on macOS, so connecting to
+        # 127.0.0.1 alone 502s even while the dev server is up. Try both stacks.
+        %w[127.0.0.1 ::1].each do |host|
+          up_req = klass.new(target)
+          # Accept-Encoding is dropped so the upstream answers with plain bytes
+          # instead of gzip.
+          %w[Accept User-Agent Cookie Accept-Language Referer Range].each do |h|
+            v = req[h]
+            up_req[h] = v if v && !v.empty?
+          end
+
+          http = Net::HTTP.new(host, port)
+          http.open_timeout = 2
+          http.read_timeout  = 20
+          begin
+            resp = http.request(up_req)
+            break
+          rescue *PROXY_CONNECT_ERRORS
+            next
+          end
+        end
+
+        if resp.nil?
+          preview_unreachable(res, port)
+          return
+        end
+
+        res.status = resp.code.to_i
+        is_html = false
+        is_css  = false
+        upstream_frameable = true
+        resp.each_capitalized do |name, value|
+          down = name.downcase
+          upstream_frameable = false if down == "x-frame-options"
+          if down == "content-security-policy" || down == "content-security-policy-report-only"
+            upstream_frameable = false if value =~ /frame-ancestors/i
+            value = strip_frame_ancestors(value)
+            next if value.nil? || value.empty?
+          end
+          next if PROXY_SKIP_HEADERS.include?(down)
+          if down == "content-type"
+            is_html = value.start_with?("text/html")
+            is_css  = value.start_with?("text/css")
+          end
+          res[name] = value
+        end
+        # Tells the preview panel whether the upstream can be framed directly.
+        # Vite-style dev servers send no X-Frame-Options, and their JS relies
+        # on absolute-path ESM imports the proxy cannot rewrite — for those,
+        # a direct iframe (which also keeps HMR websockets alive) is the only
+        # rendering path that works.
+        res["X-Clacky-Upstream-Frameable"] = upstream_frameable ? "1" : "0"
+        if req.request_method != "HEAD"
+          body = resp.body.to_s
+          if is_html
+            body = rewrite_preview_paths(body, port)
+          elsif is_css
+            body = rewrite_preview_css(body, port)
+          end
+          res.body = body
+        end
+      rescue Net::ReadTimeout, Timeout::Error, EOFError
+        preview_unreachable(res, port)
+      end
+
+      # Removes the frame-ancestors directive from a Content-Security-Policy
+      # value so the proxied page may be framed, keeping the rest of the
+      # policy intact. Returns nil when nothing (or an empty policy) remains.
+      private def strip_frame_ancestors(csp)
+        stripped = csp.to_s.gsub(/frame-ancestors[^;]*;?/i, "")
+        stripped = stripped.gsub(/;\s*;/, ";").gsub(/^\s*;|;\s*$/, "").strip
+        stripped.empty? ? nil : stripped
+      end
+
+      # Rewrites absolute-path resource URLs (/assets/app.js) in a proxied HTML
+      # page to the proxy prefix so the browser resolves them against the dev
+      # server instead of the host origin. Protocol-relative (//), already
+      # proxied and scheme URLs are left untouched.
+      private def rewrite_preview_paths(html, port)
+        prefix = "/preview/p/#{port}"
+        html.gsub(/(\b(?:src|href)\s*=\s*["'])(\/[^"']*?)(["'])/i) do
+          if $2.start_with?("//", "/preview/p/")
+            $&
+          else
+            "#{$1}#{prefix}#{$2}#{$3}"
+          end
+        end
+      end
+
+      # Rewrites absolute-path url() references inside a proxied stylesheet so
+      # fonts/images resolve against the dev server instead of the host origin.
+      private def rewrite_preview_css(css, port)
+        prefix = "/preview/p/#{port}"
+        css.gsub(/url\(\s*(["']?)(\/[^"')]*?)\1\s*\)/i) do
+          if $2.start_with?("//", "/preview/p/")
+            $&
+          else
+            "url(#{$1}#{prefix}#{$2}#{$1})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/session_registry.rb

@@ -40,6 +40,10 @@ module Clacky
 
       # Create a new (empty) session entry and return its id.
       # agent/ui/thread are set later via with_session once they are constructed.
+      def agent_config_input_behavior
+        @agent_config.input_behavior
+      end
+
       def create(session_id:)
         raise ArgumentError, "session_id is required" if session_id.nil? || session_id.empty?
 

data/lib/clacky/server/web_ui_controller.rb

@@ -16,6 +16,10 @@ module Clacky
     class WebUIController
       include Clacky::UIInterface
 
+      def show_input_queue(entries)
+        @broadcaster.call(@session_id, { type: "input_queue", session_id: @session_id, entries: entries })
+      end
+
       attr_reader :session_id
 
       def initialize(session_id, broadcaster)
@@ -66,8 +70,9 @@ module Clacky
 
       # === Output display ===
 
-      def show_user_message(content, created_at: nil, files: [], source: :web, skill_command: nil, skill_command_display: nil)
+      def show_user_message(content, created_at: nil, files: [], source: :web, skill_command: nil, skill_command_display: nil, steering: false)
         data = { content: content }
+        data[:steering] = true if steering
         data[:created_at] = created_at if created_at
         data[:skill_command] = skill_command if skill_command
         data[:skill_command_display] = skill_command_display if skill_command_display
@@ -105,7 +110,7 @@ module Clacky
         # Channel subscribers receive the original content so they can deliver
         # local images as native attachments via send_file().
         web_content = Clacky::Utils::FileProcessor.rewrite_local_image_urls(content.to_s)
-        emit("assistant_message", content: web_content, files: files, created_at: created_at)
+        emit("assistant_message", content: web_content, files: files, created_at: created_at, interim: interim)
         forward_to_subscribers { |sub| sub.show_assistant_message(content, files: files, interim: interim) }
       end
 
@@ -144,10 +149,10 @@ module Clacky
         forward_to_subscribers { |sub| sub.show_tool_call(name, args_data) }
       end
 
-      def show_tool_result(result)
+      def show_tool_result(result, ui: nil)
         @live_tool_call = nil   # tool finished — no longer in-flight
-        emit("tool_result", result: result)
-        forward_to_subscribers { |sub| sub.show_tool_result(result) }
+        emit("tool_result", result: result, ui: ui)
+        forward_to_subscribers { |sub| sub.show_tool_result(result, ui: ui) }
       end
 
       def show_tool_error(error)

data/lib/clacky/session_manager.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "securerandom"
 require "open3"
 require "set"
+require "time"
 
 module Clacky
   class SessionManager
@@ -370,10 +371,28 @@ module Clacky
         sessions[(source == "regular" ? keep : grouped_keep)..] || []
       end
 
+      # Ranking above works off the cheap header, which cannot see the messages
+      # that the heal in load_session_file derives the real last activity from.
+      # A session written by an older build therefore ranks by a stale stamp and
+      # lands in the victims purely for being quiet on paper while it was in use
+      # recently. Give those candidates a full parse before evicting them.
+      victims = victims.reject { |session| healed_activity?(session) }
+
       victims.each { |session| soft_delete(session[:session_id]) }
       victims.size
     end
 
+    # True when a header-ranked candidate carries a stored stamp older than what
+    # a full parse reports, i.e. the ranking underestimated its last activity.
+    # Costs one parse per candidate, which is the tail of an already sorted
+    # list, not the full corpus.
+    private def healed_activity?(meta)
+      full = load_session_file(meta[:_path])
+      return false unless full
+
+      full[:updated_at].to_s > (meta[:updated_at] || meta[:created_at]).to_s
+    end
+
     # A session belongs to the "regular" pool unless it is a folded grouped
     # source (cron/ext) with no project. project_id only matters for cron/ext
     # sessions, and it lives deep in the file, so we pay for a full parse only
@@ -488,11 +507,43 @@ module Clacky
     end
 
     def load_session_file(filepath)
-      JSON.parse(File.read(filepath), symbolize_names: true)
+      data = JSON.parse(File.read(filepath), symbolize_names: true)
+      heal_stale_updated_at!(data)
+      data
     rescue JSON::ParserError, Errno::ENOENT
       nil
     end
 
+    # Trust the newest message over a stale updated_at.
+    #
+    # Sessions written before the serializer started remembering its own last
+    # stamp are already on disk with an updated_at that goes back to whenever
+    # the agent was restored — months behind the conversation. Left alone,
+    # such a session sorts (and is displayed) as old, "load more" walks past
+    # it, and cleanup ranks it as stale enough to delete.
+    private def heal_stale_updated_at!(data)
+      newest = nil
+      (data[:messages] || []).each do |message|
+        ts = message[:created_at]
+        next unless ts.is_a?(Numeric)
+        newest = ts if newest.nil? || ts > newest
+      end
+      return unless newest
+
+      stamped = begin
+        data[:updated_at] && Time.parse(data[:updated_at].to_s)
+      rescue ArgumentError, TypeError
+        nil
+      end
+      # updated_at is written as whole seconds while message timestamps are
+      # floats, so a healthy session saved in the same second as its last
+      # message looks stale by a few hundred milliseconds. Rewriting it would
+      # produce the identical string, so tolerate that much drift; genuine
+      # drift is minutes or days and is still caught.
+      newest_at = Time.at(newest)
+      data[:updated_at] = newest_at.iso8601 if stamped.nil? || newest_at - stamped > 1
+    end
+
     # 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

data/lib/clacky/skill.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "yaml"
+require "json"
 require "pathname"
 require_relative "utils/file_ignore_helper"
 require_relative "utils/gitignore_parser"
@@ -618,6 +619,53 @@ module Clacky
       content
     end
 
+    class << self
+      # Rebuild a raw SKILL.md string with the editable frontmatter fields
+      # (name/name_zh/description/description_zh) and body updated, preserving
+      # every other frontmatter line untouched.
+      def update_frontmatter_fields(raw_content, fields)
+        scalar = lambda do |value|
+          s = value.to_s
+          if s.empty? || s != s.strip
+            JSON.generate(s)
+          elsif s.match?(/\A[a-zA-Z0-9][a-zA-Z0-9 _.\-\/]*\z/)
+            s
+          else
+            JSON.generate(s)
+          end
+        end
+
+        editable = {
+          "name"           => fields["name"].to_s.strip,
+          "name_zh"        => fields["name_zh"].to_s.strip,
+          "description"    => fields["description"].to_s.strip,
+          "description_zh" => fields["description_zh"].to_s.strip
+        }
+        body = fields["body"].to_s.sub(/\A\n+/, "")
+
+        match = raw_content.match(/\A---\n(.*?)\n---[ \t]*\n?/m)
+        yaml_block = match ? match[1] : ""
+
+        lines = yaml_block.empty? ? [] : yaml_block.split("\n", -1)
+        updated = {}
+        new_lines = lines.map do |line|
+          key = line[/\A([a-zA-Z0-9_-]+):/, 1]
+          if editable.key?(key) && !updated[key]
+            updated[key] = true
+            "#{key}: #{scalar.call(editable[key])}"
+          else
+            line
+          end
+        end
+        editable.each do |key, value|
+          next if updated[key]
+          new_lines << "#{key}: #{scalar.call(value)}"
+        end
+
+        "---\n#{new_lines.join("\n")}\n---\n\n#{body}"
+      end
+    end
+
 
   end
 end