openclacky 1.3.11 → 1.4.1

data/lib/clacky/tools/terminal.rb

@@ -607,9 +607,22 @@ module Clacky
           ""
         )
 
-        # Pass 1: anchored strip — the full wrapper echoed at the start,
-        # possibly spanning multiple real newlines.
-        text = text.sub(/\A\{.*?"\$__clacky_ec"\s*\n?/m, "")
+        # Pass 1: anchored strip — remove ONLY the wrapper's echoed head
+        # line (`{ USER_CMD`) at the very start of the buffer, and ONLY
+        # when a matching wrapper tail fingerprint (`}...; __clacky_ec=$?`)
+        # actually exists somewhere in the buffer. The guard is what keeps
+        # us from eating a real first line of user output that merely
+        # happens to start with `{` (e.g. JSON like `{"key": ...}`).
+        # We test the tail with a separate anchor-free `match?` (linear, no
+        # backtracking) rather than a lookahead, to avoid catastrophic
+        # regex backtracking on large `{`-prefixed output. We strip a
+        # single line (`[^\n]*`, not cross-line `.*?`): a multi-line command
+        # echoed in cooked mode puts the wrapper tail *after* the real
+        # output, so cross-line greed would swallow that output whole. The
+        # tail itself is removed by the fingerprint passes below.
+        if text.start_with?("{") && text.match?(/\}[^\n;]*; *__clacky_ec=\$\?/)
+          text = text.sub(/\A\{[^\n]*\n/, "")
+        end
 
         # Pass 2: token-aware global strip — remove any leftover wrapper
         # echo fragment, wherever it sits. Requires the session token so
@@ -629,9 +642,11 @@ module Clacky
           # 2b. Single-line shape: everything collapsed onto one line.
           # Strip from the wrapper's `}; __clacky_ec=$?` pivot (or the
           # opening `{` if still present on that line) through the end of
-          # the printf invocation (`"$__clacky_ec"`).
+          # the printf invocation (`"$__clacky_ec"`). The optional
+          # `[^\n;]*` between `}` and `;` absorbs a WSL `</dev/null`
+          # stdin redirect spliced onto the group.
           text = text.gsub(
-            /[^\n]*\}; *__clacky_ec=\$\?; *printf[^\n]*__CLACKY_DONE_#{token_re}_[^\n]*"\$__clacky_ec"[^\n]*\n?/,
+            /[^\n]*\}[^\n;]*; *__clacky_ec=\$\?; *printf[^\n]*__CLACKY_DONE_#{token_re}_[^\n]*"\$__clacky_ec"[^\n]*\n?/,
             ""
           )
 
@@ -653,9 +668,10 @@ module Clacky
         # private double-underscore var name that user code effectively
         # never emits — so we strip anything between them (non-greedy,
         # multiline-aware) to also handle width-wrap that inserted
-        # real \n breaks inside the echo.
+        # real \n breaks inside the echo. `[^\n;]*` between `}` and `;`
+        # absorbs a WSL `</dev/null` stdin redirect on the group.
         text = text.gsub(
-          /[^\n]*\}; *__clacky_ec=\$\?.*?"\$__clacky_ec"[^\n]*\n?/m,
+          /[^\n]*\}[^\n;]*; *__clacky_ec=\$\?.*?"\$__clacky_ec"[^\n]*\n?/m,
           ""
         )
 
@@ -663,7 +679,7 @@ module Clacky
         # truncation cut off everything after `__clacky_ec=$?`). Still a
         # reliable fingerprint thanks to the `__clacky_ec` var name.
         text = text.gsub(
-          /[^\n]*\}; *__clacky_ec=\$\?;?[^\n]*\n?/,
+          /[^\n]*\}[^\n;]*; *__clacky_ec=\$\?;?[^\n]*\n?/,
           ""
         )
 

data/lib/clacky/ui2/layout_manager.rb

@@ -402,6 +402,10 @@ module Clacky
           screen.show_cursor
           screen.flush
         end
+        # Restore cooked mode so the terminal is usable after exit, regardless
+        # of which exit path was taken (some call exit(0) and bypass the
+        # input_loop ensure). Idempotent; safe to call more than once.
+        screen.disable_raw_mode
       end
 
       # /clear: wipe output area + buffer, keep fixed area.

data/lib/clacky/ui2/screen_buffer.rb

@@ -118,14 +118,42 @@ module Clacky
         @height = TTY::Screen.height
       end
 
-      # Enable raw mode (disable line buffering)
+      # Enable raw mode (disable line buffering). The very first time it runs it
+      # snapshots the terminal's original settings (via `stty -g`) so the exact
+      # pre-clacky state can be restored on exit — `IO#cooked!` only applies a
+      # generic cooked profile and does not restore flow-control (IXON) and other
+      # bits, which on macOS leaves the shell in a broken input state.
       def enable_raw_mode
+        return unless $stdin.tty?
+
+        @original_stty ||= capture_stty
         $stdin.raw!
       end
 
-      # Disable raw mode
+      # Disable raw mode. Idempotent and tty-guarded so it can be safely called
+      # from any exit path. Restores the exact original terminal settings when a
+      # snapshot exists, then flushes pending input so stray bytes don't leak to
+      # the shell. Falls back to `IO#cooked!` when no snapshot is available.
       def disable_raw_mode
-        $stdin.cooked!
+        return unless $stdin.tty?
+
+        $stdin.cooked! unless @original_stty && restore_stty(@original_stty)
+        $stdin.ioflush
+      rescue IOError, Errno::ENOTTY
+        nil
+      end
+
+      private def capture_stty
+        out = Clacky::Utils::Encoding.cmd_to_utf8(`stty -g 2>/dev/null`).strip
+        out.empty? ? nil : out
+      rescue StandardError
+        nil
+      end
+
+      private def restore_stty(state)
+        system("stty", state, out: File::NULL, err: File::NULL)
+      rescue StandardError
+        false
       end
 
       # Read a single character without echo

data/lib/clacky/utils/environment_detector.rb

@@ -52,17 +52,24 @@ module Clacky
         end
       end
 
-      # Convert a Windows-style path to a WSL/Linux-side path.
-      # e.g. "C:/Users/foo/file.txt" → "/mnt/c/Users/foo/file.txt"
-      # Returns the original path unchanged on non-WSL or if already a Linux path.
-      # @param path [String]
-      # @return [String]
+      # Convert a Windows-style path (incl. the "/C:/" three-slash-URL form) to
+      # a WSL /mnt path. No-op on non-WSL or non-drive-letter paths.
       def self.win_to_linux_path(path)
-        return path unless os_type == :wsl && path.match?(/\A[A-Za-z]:[\/\\]/)
+        return path unless os_type == :wsl
+
+        m = path.match(%r{\A/?([A-Za-z]):[/\\](.*)}m)
+        return path unless m
+
+        "/mnt/#{m[1].downcase}/#{m[2].gsub("\\", "/")}"
+      end
 
-        drive = path[0].downcase
-        rest  = path[2..].gsub("\\", "/")
-        "/mnt/#{drive}#{rest}"
+      # Resolve a "file://" URL or bare path into a real local path:
+      # strip "file://", percent-decode, WSL drive-letter normalize, then expand.
+      def self.resolve_local_path(href)
+        path = href.to_s.sub(%r{\Afile://}, "")
+        path = CGI.unescape(path)
+        path = win_to_linux_path(path)
+        File.expand_path(path)
       end
 
       # Convert a Linux-side path to a Windows-style path via wslpath.

data/lib/clacky/utils/file_processor.rb

@@ -6,6 +6,7 @@ require "securerandom"
 require "stringio"
 
 require_relative "parser_manager"
+require_relative "environment_detector"
 require "zip"
 
 module Clacky
@@ -595,71 +596,63 @@ module Clacky
       return content if content.nil? || content.empty?
 
       # Rewrite markdown image syntax ![alt](file:///path) → proxy URL
-      content = content.gsub(/!\[([^\]]*)\]\(((?:file:\/\/)?\/[^)]+)\)/) do |_match|
+      content = content.gsub(/!\[([^\]]*)\]\(((?:file:\/\/)?(?:~\/|\/)[^)]+)\)/) do |_match|
         alt  = Regexp.last_match(1)
         href = Regexp.last_match(2)
 
-        path = href.sub(%r{\Afile://}, "")
-        path = CGI.unescape(path)
+        real = Clacky::Utils::EnvironmentDetector.resolve_local_path(href)
 
-        ext = File.extname(path).downcase
-        if LOCAL_MEDIA_EXTENSIONS.include?(ext) && File.exist?(path)
-          encoded = CGI.escape(href)
-          "![#{alt}](/api/local-image?path=#{encoded})"
+        ext = File.extname(real).downcase
+        if LOCAL_MEDIA_EXTENSIONS.include?(ext) && File.exist?(real)
+          "![#{alt}](#{local_image_proxy_url(href, real)})"
         else
           _match
         end
       end
 
       # Rewrite <video src="file:///path/vid.mp4" ...> → proxy URL
-      content = content.gsub(/<video\b([^>]*)\bsrc="((?:file:\/\/)?\/[^"]+)"([^>]*)>/) do |_match|
+      content = content.gsub(/<video\b([^>]*)\bsrc="((?:file:\/\/)?(?:~\/|\/)[^"]+)"([^>]*)>/) do |_match|
         pre  = Regexp.last_match(1) || ""
         href = Regexp.last_match(2)
         post = Regexp.last_match(3) || ""
 
-        path = href.sub(%r{\Afile://}, "")
-        path = CGI.unescape(path)
+        real = Clacky::Utils::EnvironmentDetector.resolve_local_path(href)
 
-        ext = File.extname(path).downcase
-        if LOCAL_VIDEO_EXTENSIONS.include?(ext) && File.exist?(path)
-          encoded = CGI.escape(href)
-          "<video#{pre} src=\"/api/local-image?path=#{encoded}\"#{post}>"
+        ext = File.extname(real).downcase
+        if LOCAL_VIDEO_EXTENSIONS.include?(ext) && File.exist?(real)
+          "<video#{pre} src=\"#{local_image_proxy_url(href, real)}\"#{post}>"
         else
           _match
         end
       end
 
       # Rewrite <audio src="file:///path/audio.wav" ...> → proxy URL
-      content = content.gsub(/<audio\b([^>]*)\bsrc="((?:file:\/\/)?\/[^"]+)"([^>]*)>/) do |_match|
+      content = content.gsub(/<audio\b([^>]*)\bsrc="((?:file:\/\/)?(?:~\/|\/)[^"]+)"([^>]*)>/) do |_match|
         pre  = Regexp.last_match(1) || ""
         href = Regexp.last_match(2)
         post = Regexp.last_match(3) || ""
 
-        path = href.sub(%r{\Afile://}, "")
-        path = CGI.unescape(path)
+        real = Clacky::Utils::EnvironmentDetector.resolve_local_path(href)
 
-        ext = File.extname(path).downcase
-        if LOCAL_AUDIO_EXTENSIONS.include?(ext) && File.exist?(path)
-          encoded = CGI.escape(href)
-          "<audio#{pre} src=\"/api/local-image?path=#{encoded}\"#{post}>"
+        ext = File.extname(real).downcase
+        if LOCAL_AUDIO_EXTENSIONS.include?(ext) && File.exist?(real)
+          "<audio#{pre} src=\"#{local_image_proxy_url(href, real)}\"#{post}>"
         else
           _match
         end
       end
 
       # Rewrite video/audio markdown links [text](file:///path) → proxy URL
-      content = content.gsub(/(?<!!)\[([^\]]*)\]\(((?:file:\/\/)?\/[^)]+)\)/) do |_match|
+      content = content.gsub(/(?<!!)\[([^\]]*)\]\(((?:file:\/\/)?(?:~\/|\/)[^)]+)\)/) do |_match|
         text = Regexp.last_match(1)
         href = Regexp.last_match(2)
 
-        path = href.sub(%r{\Afile://}, "")
-        path = CGI.unescape(path)
+        real = Clacky::Utils::EnvironmentDetector.resolve_local_path(href)
 
-        ext = File.extname(path).downcase
+        ext = File.extname(real).downcase
         if LOCAL_VIDEO_EXTENSIONS.include?(ext) || LOCAL_AUDIO_EXTENSIONS.include?(ext)
-          if File.exist?(path)
-            encoded = CGI.escape(href)
-            "[#{text}](/api/local-image?path=#{encoded})"
+          if File.exist?(real)
+            "[#{text}](#{local_image_proxy_url(href, real)})"
           else
             _match
           end
@@ -670,6 +663,15 @@ module Clacky
 
       content
     end
+
+    # Build a proxy URL for a local media file, appending a version param
+    # derived from the file mtime so an overwritten same-name file produces a
+    # different URL and defeats the browser's in-memory image cache.
+    def self.local_image_proxy_url(href, path)
+      encoded = CGI.escape(href)
+      version = File.mtime(path).to_i
+      "/api/local-image?path=#{encoded}&v=#{version}"
+    end
   end
   end
 end

data/lib/clacky/utils/model_pricing.rb

@@ -237,6 +237,55 @@ module Clacky
         }
       },
 
+      # Kimi K3 flagship model (1M context, native vision, tool calling).
+      # Source: https://platform.moonshot.ai (USD / 1M tokens)
+      "kimi-k3" => {
+        input: {
+          default: 3.00,                   # $3.00/MTok cache miss
+          over_200k: 3.00
+        },
+        output: {
+          default: 15.00,                  # $15.00/MTok
+          over_200k: 15.00
+        },
+        cache: {
+          write: 3.00,                     # no separate write charge; bill at miss rate
+          read: 0.30                       # $0.30/MTok cache hit
+        }
+      },
+
+      # Kimi K2.7 Code (256K context, multimodal coding model).
+      # Source: https://platform.moonshot.ai (USD / 1M tokens)
+      "kimi-k2.7-code" => {
+        input: {
+          default: 0.95,                   # $0.95/MTok cache miss
+          over_200k: 0.95
+        },
+        output: {
+          default: 4.00,                   # $4.00/MTok
+          over_200k: 4.00
+        },
+        cache: {
+          write: 0.95,                     # no separate write charge; bill at miss rate
+          read: 0.19                       # $0.19/MTok cache hit
+        }
+      },
+
+      "kimi-k2.7-code-highspeed" => {
+        input: {
+          default: 1.90,                   # $1.90/MTok cache miss
+          over_200k: 1.90
+        },
+        output: {
+          default: 8.00,                   # $8.00/MTok
+          over_200k: 8.00
+        },
+        cache: {
+          write: 1.90,                     # no separate write charge; bill at miss rate
+          read: 0.38                       # $0.38/MTok cache hit
+        }
+      },
+
       # Google Gemini 3 series (via Vertex AI). Tiered at 200K input tokens
       # for Pro; Flash has flat pricing.
       "gemini-3.1-pro" => {

data/lib/clacky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Clacky
-  VERSION = "1.3.11"
+  VERSION = "1.4.1"
 end