openclacky 1.3.3 → 1.3.4

data/lib/clacky/server/api_extension_dispatcher.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "json"
+require "timeout"
+require "uri"
+
+module Clacky
+  module Server
+    # Routes /api/ext/<name>/<sub-path> requests to the matching ApiExtension
+    # subclass. Wraps each handler invocation with a timeout and a unified
+    # JSON error envelope so a misbehaving extension cannot break neighboring
+    # extensions or the host process.
+    module ApiExtensionDispatcher
+      MOUNT_PREFIX = "/api/ext/"
+
+      class << self
+        # Public entry called from HttpServer#_dispatch_rest.
+        # Returns true to indicate the request was handled (200/4xx/5xx).
+        def handle(req, res, http_server:)
+          ext_id, sub_path = parse_path(req.path)
+          return not_found(res, "extension id missing") unless ext_id
+
+          klass = Clacky::ApiExtension.registry[ext_id]
+          return not_found(res, "extension '#{ext_id}' not found") unless klass
+
+          method = req.request_method.to_s.downcase.to_sym
+          route, params = find_route(klass, method, sub_path)
+          return not_found(res, "no route for #{req.request_method} #{req.path}") unless route
+
+          # Public-endpoint check is done at HttpServer level (it owns access-key
+          # logic); by the time we get here, auth has already been resolved.
+
+          timeout_sec = route.options[:timeout] || klass.class_timeout || Clacky::ApiExtension::DEFAULT_TIMEOUT
+          invoke_route(klass, route, params, req, res, http_server, timeout_sec)
+          true
+        end
+
+        # Tells HttpServer whether a given /api/ext/... path can skip access-key
+        # auth, so the host can keep its single-source-of-truth auth logic.
+        def public_path?(path, method)
+          ext_id, sub_path = parse_path(path)
+          return false unless ext_id
+
+          klass = Clacky::ApiExtension.registry[ext_id]
+          return false unless klass
+          return false if klass.public_paths.empty?
+
+          route, _params = find_route(klass, method.to_s.downcase.to_sym, sub_path)
+          return false unless route
+
+          klass.public_paths.include?(route.pattern)
+        end
+
+        private def parse_path(path)
+          return [nil, nil] unless path.to_s.start_with?(MOUNT_PREFIX)
+
+          tail = path[MOUNT_PREFIX.length..]
+          slash = tail.index("/")
+          if slash
+            [tail[0...slash], tail[slash..]]
+          else
+            [tail, "/"]
+          end
+        end
+
+        private def find_route(klass, method, sub_path)
+          klass.routes.each do |route|
+            next unless route.method == method
+            next unless (m = route.regex.match(sub_path))
+
+            params = {}
+            route.param_names.each_with_index do |name, i|
+              params[name] = URI.decode_www_form_component(m[i + 1].to_s)
+            end
+            return [route, params]
+          end
+          [nil, nil]
+        end
+
+        private def invoke_route(klass, route, params, req, res, http_server, timeout_sec)
+          instance = klass.new(req: req, res: res, route: route, params: params, http_server: http_server)
+          Timeout.timeout(timeout_sec) { instance.invoke }
+
+          # Handler exited without writing — empty 204
+          empty_response(res)
+        rescue Clacky::ApiExtension::Halt => halt
+          write_response(res, halt.status, halt.payload, halt.content_type)
+        rescue Timeout::Error
+          Clacky::Logger.warn("[api_ext:#{klass.ext_id}] Timed out after #{timeout_sec}s on #{route.method.upcase} #{route.pattern}")
+          write_json(res, 503, error: "request timed out")
+        rescue StandardError => e
+          Clacky::Logger.warn("[api_ext:#{klass.ext_id}] #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
+          write_json(res, 500, error: e.message)
+        end
+
+        private def write_response(res, status, body, content_type)
+          res.status = status
+          res.content_type = content_type
+          res["Access-Control-Allow-Origin"] = "*"
+          res.body = body
+        end
+
+        private def write_json(res, status, payload)
+          write_response(res, status, JSON.generate(payload), "application/json; charset=utf-8")
+        end
+
+        private def empty_response(res)
+          res.status = 204
+          res["Access-Control-Allow-Origin"] = "*"
+          res.body = ""
+        end
+
+        private def not_found(res, message)
+          write_json(res, 404, error: message)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/clacky/server/http_server.rb

@@ -218,6 +218,7 @@ module Clacky
       end
 
       def start
+        @start_time = Time.now
         # One-time migration: move legacy trash contents into file-trash/ subdirectory.
         Clacky::TrashDirectory.migrate_legacy_if_needed
 
@@ -381,6 +382,12 @@ module Clacky
         # Auto-create a default session on startup
         create_default_session
 
+        # Load user-defined HTTP API extensions from ~/.clacky/api_ext/.
+        # Done here (not at gem load) so handlers can resolve session_manager
+        # and other host helpers as soon as they are wired up.
+        # The loader logs its own summary via Clacky::Logger.
+        Clacky::ApiExtensionLoader.load_all
+
         # Start the background scheduler
         @scheduler.start
         puts "   Scheduler: #{@scheduler.schedules.size} task(s) loaded"
@@ -412,6 +419,8 @@ module Clacky
         path   = req.path
         method = req.request_method
 
+        Thread.current[:lang] = req["X-Lang"].to_s.strip.then { |l| l.empty? ? nil : l }
+
         # Access key guard (skip for WebSocket upgrades)
         return unless check_access_key(req, res)
 
@@ -430,6 +439,11 @@ module Clacky
         # generous 90s so retry + failover can complete without being cut short.
         timeout_sec = if path.start_with?("/api/brand")
           90
+        elsif path.start_with?(Clacky::Server::ApiExtensionDispatcher::MOUNT_PREFIX)
+          # api_ext dispatcher applies its own per-route timeout (capped at
+          # ApiExtension::MAX_TIMEOUT). Use the upper bound here so the outer
+          # guard never cuts a long-running custom handler short.
+          Clacky::ApiExtension::MAX_TIMEOUT + 30
         elsif path == "/api/tool/browser"
           30
         elsif path == "/api/exchange-rate"
@@ -469,6 +483,13 @@ module Clacky
         path   = req.path
         method = req.request_method
 
+        # User-defined HTTP API extensions live under ~/.clacky/api_ext/<name>/
+        # and mount at /api/ext/<name>/...  Routed through a separate dispatcher
+        # so the host's giant case table stays focused on built-in endpoints.
+        if path.start_with?(Clacky::Server::ApiExtensionDispatcher::MOUNT_PREFIX)
+          return if Clacky::Server::ApiExtensionDispatcher.handle(req, res, http_server: self)
+        end
+
         case [method, path]
         when ["GET",    "/api/sessions"]      then api_list_sessions(req, res)
         when ["POST",   "/api/sessions"]      then api_create_session(req, res)
@@ -483,8 +504,6 @@ module Clacky
         when ["POST",   "/api/config/test"]   then api_test_config(req, res)
         when ["POST",   "/api/config/media/test"] then api_test_media_config(req, res)
         when ["GET",    "/api/config/media"]  then api_get_media_config(res)
-        when ["GET",    "/api/config/media-output-dir"]   then api_get_media_output_dir(res)
-        when ["PATCH",  "/api/config/media-output-dir"]   then api_update_media_output_dir(req, res)
         when ["GET",    "/api/config/ocr"]    then api_get_ocr_config(res)
         when ["PATCH",  "/api/config/ocr"]    then api_update_ocr_config(req, res)
         when ["POST",   "/api/config/ocr/test"] then api_test_ocr_config(req, res)
@@ -608,6 +627,8 @@ module Clacky
             api_session_time_machine_restore_preview(session_id, task_id, res)
           elsif method == "GET" && path == "/api/dirs"
             api_browse_dirs(req, res)
+          elsif method == "POST" && path == "/api/dirs/mkdir"
+            api_dirs_mkdir(req, res)
           elsif method == "GET" && path.match?(%r{^/api/sessions/[^/]+/files$})
             session_id = path.sub("/api/sessions/", "").sub("/files", "")
             api_session_files(session_id, req, res)
@@ -671,6 +692,12 @@ module Clacky
           elsif method == "PATCH" && path.match?(%r{^/api/skills/[^/]+/toggle$})
             name = URI.decode_www_form_component(path.sub("/api/skills/", "").sub("/toggle", ""))
             api_toggle_skill(name, req, res)
+          elsif method == "GET" && path.match?(%r{^/api/skills/[^/]+/content$})
+            name = URI.decode_www_form_component(path.sub("/api/skills/", "").sub("/content", ""))
+            api_skill_content_get(name, res)
+          elsif method == "PUT" && path.match?(%r{^/api/skills/[^/]+/content$})
+            name = URI.decode_www_form_component(path.sub("/api/skills/", "").sub("/content", ""))
+            api_skill_content_update(name, req, res)
           elsif method == "DELETE" && path.match?(%r{^/api/skills/[^/]+$})
             name = URI.decode_www_form_component(path.sub("/api/skills/", ""))
             api_delete_skill(name, res)
@@ -1300,11 +1327,8 @@ module Clacky
 
         aspect_ratio = body["aspect_ratio"].to_s
         aspect_ratio = "landscape" if aspect_ratio.empty?
-        output_dir   = Clacky::Media::OutputDir.resolve(
-          param:      body["output_dir"],
-          configured: @agent_config.media_output_dir,
-          fallback:   @agent_config.default_working_dir || Dir.pwd
-        )
+        output_dir   = body["output_dir"].to_s
+        output_dir   = @agent_config.default_working_dir || Dir.pwd if output_dir.empty?
 
         result = Clacky::Media::Generator.new(@agent_config).generate_image(
           prompt: prompt,
@@ -1335,11 +1359,8 @@ module Clacky
         aspect_ratio = "landscape" if aspect_ratio.empty?
         duration     = body["duration_seconds"]
         image        = body["image"]
-        output_dir   = Clacky::Media::OutputDir.resolve(
-          param:      body["output_dir"],
-          configured: @agent_config.media_output_dir,
-          fallback:   @agent_config.default_working_dir || Dir.pwd
-        )
+        output_dir   = body["output_dir"].to_s
+        output_dir   = @agent_config.default_working_dir || Dir.pwd if output_dir.empty?
 
         result = Clacky::Media::Generator.new(@agent_config).generate_video(
           prompt: prompt,
@@ -1367,11 +1388,8 @@ module Clacky
         end
 
         voice      = body["voice"]
-        output_dir = Clacky::Media::OutputDir.resolve(
-          param:      body["output_dir"],
-          configured: @agent_config.media_output_dir,
-          fallback:   @agent_config.default_working_dir || Dir.pwd
-        )
+        output_dir = body["output_dir"].to_s
+        output_dir = @agent_config.default_working_dir || Dir.pwd if output_dir.empty?
 
         result = Clacky::Media::Generator.new(@agent_config).generate_speech(
           input: input,
@@ -2415,6 +2433,13 @@ module Clacky
         # skills/curl talk to the server without an access key.
         return true if loopback_ip?(ip)
 
+        # Public API extension endpoints (declared via public_endpoint + meta.yml
+        # public:true) are intentionally exposed without auth — used for
+        # third-party webhooks where the extension does its own signature check.
+        if Clacky::Server::ApiExtensionDispatcher.public_path?(req.path, req.request_method)
+          return true
+        end
+
         candidate = extract_key(req)
 
         # Lazily evict expired lockout entries to prevent unbounded memory growth.
@@ -3821,7 +3846,7 @@ module Clacky
         # Directories first, then files; both case-insensitive alphabetical.
         items.sort_by! { |it| [it[:type] == "dir" ? 0 : 1, it[:name].downcase] }
 
-        json_response(res, 200, { root: display_root, path: rel, entries: items })
+        json_response(res, 200, { root: display_root, path: rel, home: Dir.home, default: default_working_dir, entries: items })
       rescue StandardError => e
         json_response(res, 500, { error: e.message })
       end
@@ -3859,11 +3884,56 @@ module Clacky
         end
         items.sort_by! { |it| it[:name].downcase }
 
-        json_response(res, 200, { root: target, path: target, parent: File.dirname(target), home: Dir.home, entries: items })
+        json_response(res, 200, { root: target, path: target, parent: File.dirname(target), home: Dir.home, default: default_working_dir, entries: items })
       rescue StandardError => e
         json_response(res, 500, { error: e.message })
       end
 
+      # ── Directory mutation API used by the path picker ─────────────────
+      # Validate a folder name supplied by the picker UI:
+      # non-empty, no path separators, not "."/"..", short-ish.
+      private def picker_valid_name?(name)
+        return false if name.nil?
+        return false if name.empty? || name.length > 255
+        return false if name == "." || name == ".."
+        # Reject path separators (forward slash and backslash).
+        return false if name.match?(%r{[/\\]})
+        true
+      end
+
+      # POST /api/dirs/mkdir
+      # Body: { parent: "/abs/parent", name: "New Folder" }
+      def api_dirs_mkdir(req, res)
+        body   = parse_json_body(req)
+        parent = body["parent"].to_s
+        name   = body["name"].to_s.strip
+
+        return json_response(res, 422, { error: "parent must be an absolute path" }) unless parent.start_with?("/")
+        return json_response(res, 422, { error: "name is invalid" }) unless picker_valid_name?(name)
+
+        parent = File.expand_path(parent)
+        return json_response(res, 404, { error: "Parent directory not found" }) unless Dir.exist?(parent)
+
+        target = File.join(parent, name)
+        return json_response(res, 422, { error: "Already exists" }) if File.exist?(target)
+
+        FileUtils.mkdir_p(target)
+        json_response(res, 200, { ok: true, path: target, name: name })
+      rescue StandardError => e
+        json_response(res, 500, { error: e.message })
+      end
+
+      # NOTE: there is NO PATCH /api/dirs/rename endpoint.
+      # Directory rename was intentionally removed from the picker —
+      # too dangerous for a one-click UI affordance (renaming an in-use
+      # workspace mid-session can break tasks, sessions, MCP configs, …).
+      # Use the terminal for that.
+
+      # NOTE: there is NO DELETE /api/dirs/delete endpoint.
+      # Directory deletion was intentionally removed from the picker —
+      # too dangerous for a one-click UI affordance, even with a trash
+      # bucket fallback. Use the terminal (safe_rm) for that.
+
       # Body: { enabled: true/false }
       def api_toggle_skill(name, req, res)
         body    = parse_json_body(req)
@@ -3880,6 +3950,47 @@ module Clacky
         json_response(res, 422, { error: e.message })
       end
 
+      private def api_skill_content_get(name, res)
+        @skill_loader.load_all
+        skill = @skill_loader[name]
+        return json_response(res, 404, { ok: false, error: "Skill not found: #{name}" }) unless skill
+
+        skill_md = File.join(skill.directory.to_s, "SKILL.md")
+        unless File.exist?(skill_md)
+          return json_response(res, 404, { ok: false, error: "SKILL.md not found" })
+        end
+
+        json_response(res, 200, {
+          ok:      true,
+          name:    skill.identifier,
+          content: File.read(skill_md),
+          path:    skill_md
+        })
+      end
+
+      private def api_skill_content_update(name, req, res)
+        @skill_loader.load_all
+        skill = @skill_loader[name]
+        return json_response(res, 404, { ok: false, error: "Skill not found: #{name}" }) unless skill
+
+        if skill.source_path.nil? || @skill_loader.loaded_from[skill.identifier] == :default
+          return json_response(res, 403, { ok: false, error: "System skills cannot be edited" })
+        end
+
+        data    = parse_json_body(req)
+        content = data["content"].to_s
+        skill_md = File.join(skill.directory.to_s, "SKILL.md")
+        unless File.exist?(skill_md)
+          return json_response(res, 404, { ok: false, error: "SKILL.md not found" })
+        end
+
+        File.write(skill_md, content)
+        @skill_loader.load_all
+        json_response(res, 200, { ok: true, name: skill.identifier })
+      rescue StandardError => e
+        json_response(res, 500, { ok: false, error: e.message })
+      end
+
       private def api_delete_skill(name, res)
         skill = @skill_loader[name]
         return json_response(res, 404, { error: "Skill not found: #{name}" }) unless skill
@@ -4738,83 +4849,6 @@ module Clacky
         json_response(res, 422, { error: e.message })
       end
 
-      # GET /api/config/media-output-dir
-      # Returns the user-configured directory under which generated media
-      # files (images / videos / audio) are persisted, plus the default
-      # the system would use if the value is empty. The frontend uses
-      # `default` as a placeholder hint.
-      def api_get_media_output_dir(res)
-        json_response(res, 200, {
-          ok:      true,
-          value:   @agent_config.media_output_dir.to_s,
-          default: default_media_output_dir
-        })
-      end
-
-      # PATCH /api/config/media-output-dir
-      # Body: { "value": "<absolute or ~-prefixed path, or empty to clear>" }
-      # Empty / blank value clears the override, restoring the legacy
-      # fallback (default_working_dir → Dir.pwd) for new generations.
-      def api_update_media_output_dir(req, res)
-        body = parse_json_body(req)
-        return json_response(res, 400, { error: "Invalid JSON" }) unless body
-
-        raw = body["value"].to_s.strip
-        if raw.empty?
-          @agent_config.media_output_dir = nil
-          @agent_config.save
-          return json_response(res, 200, {
-            ok:      true,
-            value:   "",
-            default: default_media_output_dir
-          })
-        end
-
-        expanded = File.expand_path(raw)
-
-        # Reject anything that's not an absolute path after `~` expansion.
-        # Relative paths would silently resolve against the server's CWD,
-        # which is exactly the source of confusion this setting exists to fix.
-        unless expanded.start_with?("/")
-          return json_response(res, 422, {
-            error: "media_output_dir must be an absolute path or start with ~"
-          })
-        end
-
-        # Create the directory if missing; surface filesystem errors plainly
-        # so the user can fix permissions / typo without reading server logs.
-        begin
-          FileUtils.mkdir_p(expanded)
-        rescue Errno::EACCES, Errno::EROFS, Errno::ENOSPC, Errno::ENOTDIR => e
-          return json_response(res, 422, {
-            error: "cannot create directory: #{e.message}"
-          })
-        end
-
-        unless File.writable?(expanded)
-          return json_response(res, 422, {
-            error: "directory is not writable: #{expanded}"
-          })
-        end
-
-        @agent_config.media_output_dir = expanded
-        @agent_config.save
-        json_response(res, 200, {
-          ok:      true,
-          value:   expanded,
-          default: default_media_output_dir
-        })
-      rescue => e
-        json_response(res, 422, { error: e.message })
-      end
-
-      # The path the resolver would pick if media_output_dir is blank.
-      # Mirrors the fallback chain inside Clacky::Media::OutputDir.resolve so
-      # the frontend can render it as a placeholder hint (no second source
-      # of truth — both call sites read default_working_dir).
-      private def default_media_output_dir
-        @agent_config.default_working_dir.to_s.empty? ? Dir.pwd : @agent_config.default_working_dir
-      end
       # DEPRECATED: this endpoint previously accepted the entire models array
       # and replaced @models in place. That design was fragile — any missing
       # or stale field on ANY row could wipe other rows' api_keys. It has
@@ -4839,8 +4873,15 @@ module Clacky
         model    = body["model"].to_s.strip
         base_url = body["base_url"].to_s.strip
         api_key  = body["api_key"].to_s
-        # Masked placeholders are never a valid api_key on creation —
-        # a brand-new model MUST come with a real key.
+        # When duplicating, the frontend sends source_id so we can inherit the
+        # real key without ever transmitting it back to the client.
+        if api_key.empty? || api_key.include?("****")
+          source_id = body["source_id"].to_s
+          unless source_id.empty?
+            source  = @agent_config.models.find { |m| m["id"] == source_id }
+            api_key = source["api_key"].to_s if source
+          end
+        end
         if api_key.empty? || api_key.include?("****")
           return json_response(res, 422, { error: "api_key is required" })
         end
@@ -5558,6 +5599,7 @@ module Clacky
 
         when "message"
           session_id = msg["session_id"] || conn.session_id
+          Thread.current[:lang] = msg["lang"].to_s.strip.then { |l| l.empty? ? nil : l }
           # Merge legacy images array into files as { data_url:, name:, mime_type: } entries
           raw_images = (msg["images"] || []).map do |data_url|
             { "data_url" => data_url, "name" => "image.jpg", "mime_type" => "image/jpeg" }
@@ -5654,13 +5696,15 @@ module Clacky
         end
 
         # Broadcast user message through web_ui so channel subscribers (飞书/企微) receive it.
+        # created_at is shared with agent.run so the history entry and the bubble use the same value.
+        msg_created_at = Time.now.to_f
         web_ui = nil
         @registry.with_session(session_id) { |s| web_ui = s[:ui] }
-        web_ui&.show_user_message(content, source: :web)
+        web_ui&.show_user_message(content, created_at: msg_created_at, 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) }
+        run_agent_task(session_id, agent) { agent.run(content, files: files, created_at: msg_created_at) }
       end
 
       def deliver_confirmation(session_id, conf_id, result)
@@ -5847,7 +5891,9 @@ module Clacky
 
         broadcast_session_update(session_id)
 
+        locale = Thread.current[:lang]
         thread = Thread.new do
+          Thread.current[:lang] = locale
           task.call
           @registry.update(session_id, status: :idle, error: nil)
           broadcast_session_update(session_id)
@@ -5874,10 +5920,11 @@ module Clacky
             preset = Clacky::Providers::PRESETS[e.provider_id]
             top_up_url = preset && preset["website_url"]
           end
-          @registry.update(session_id, status: :error, error: e.message, error_code: code, top_up_url: top_up_url)
+          user_message = e.respond_to?(:display_message) && e.display_message ? e.display_message : e.message
+          @registry.update(session_id, status: :error, error: user_message, error_code: code, top_up_url: top_up_url)
           broadcast_session_update(session_id)
-          web_ui&.show_error(e.message, code: code, top_up_url: top_up_url)
-          @session_manager.save(agent.to_session_data(status: :error, error_message: e.message))
+          web_ui&.show_error(user_message, code: code, top_up_url: top_up_url)
+          @session_manager.save(agent.to_session_data(status: :error, error_message: user_message))
         end
         @registry.with_session(session_id) { |s| s[:thread] = thread }
       end

data/lib/clacky/server/session_registry.rb

@@ -440,7 +440,7 @@ module Clacky
 
       private def persist_and_release(id, session)
         agent = session[:agent]
-        @session_manager&.save(agent.to_session_data(status: :success)) if agent
+        @session_manager&.save(agent.to_session_data(status: :success, preserve_updated_at: true)) if agent
 
         @mutex.synchronize do
           s = @sessions[id]

data/lib/clacky/shell_hook_loader.rb

@@ -178,4 +178,4 @@ module Clacky
       base
     end
   end
-end
+end

data/lib/clacky/tools/edit.rb

@@ -67,8 +67,20 @@ module Clacky
             }
           end
 
-          # Perform replacement
-          content = replace_all ? content.gsub(actual_old_string, new_string) : content.sub(actual_old_string, new_string)
+          # Perform literal replacement.
+          #
+          # NOTE: Use the block form (`sub(old) { new }`) instead of the
+          # two-arg form (`sub(old, new)`). The two-arg form interprets
+          # backslash escapes (\&, \1, \`, \', \\) in the replacement
+          # as sed-style backreferences, silently mangling literal
+          # backslashes and these escape sequences. The block form
+          # performs no such interpretation, matching the edit tool's
+          # literal-replacement contract.
+          content = if replace_all
+                      content.gsub(actual_old_string) { new_string }
+                    else
+                      content.sub(actual_old_string) { new_string }
+                    end
 
           File.write(path, content)
 

data/lib/clacky/ui2/ui_controller.rb

@@ -47,6 +47,7 @@ module Clacky
         @input_callback = nil
         @interrupt_callback = nil
         @time_machine_callback = nil
+        @model_switch_callback = nil
         @tasks_count = 0
         @total_cost = 0.0
         @session_id = nil
@@ -192,6 +193,12 @@ module Clacky
         @time_machine_callback = block
       end
 
+      # Set callback for model switch (from /model slash command)
+      # @param block [Proc] Callback to execute on model switch
+      def on_model_switch(&block)
+        @model_switch_callback = block
+      end
+
       # Set agent for command suggestions
       # @param agent [Clacky::Agent] The agent instance with skill management
       # @param agent_profile [Clacky::AgentProfile, nil] Current agent profile for skill filtering

data/lib/clacky/version.rb

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