tina4ruby 3.13.137 → 3.13.138

data/lib/tina4/response.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 require "uri"
 
@@ -59,11 +65,30 @@ module Tina4
 
     attr_accessor :status_code, :headers, :body, :cookies
 
+    # ADR-0068: a header name must be an RFC 9110 token, and a header value,
+    # redirect location or cookie attribute may never carry CR, LF or NUL (a
+    # cookie attribute not ';' either). They are REFUSED where the developer
+    # sets them - never stripped - so the stack trace points at the line that
+    # built the value. The messages are identical in all four frameworks.
+    HEADER_TOKEN = /\A[!#$%&'*+\-.^_`|~0-9A-Za-z]+\z/
+    UNSAFE_HEADER_VALUE = /[\r\n\0]/
+    UNSAFE_COOKIE_CONTENT = /[\r\n\0;]/
+
+    def self.check_header!(name, value)
+      unless name.to_s.match?(HEADER_TOKEN)
+        raise ArgumentError, "Header name must be a valid HTTP token [#{JSON.generate(name.to_s)}]"
+      end
+      return value unless value.to_s.match?(UNSAFE_HEADER_VALUE)
+
+      raise ArgumentError, "Invalid character in header content [#{JSON.generate(name.to_s)}]"
+    end
+
     def initialize
       @status_code = 200
       @headers = { "content-type" => HTML_CONTENT_TYPE }
       @body = ""
       @cookies = nil  # Lazy -- most responses have no cookies
+      @content_type_from_header = false
     end
 
     # Chainable status setter
@@ -79,16 +104,17 @@ module Tina4
     # Callable response — auto-detects content type from data.
     # Matches Python __call__ / PHP __invoke / Node response() pattern.
     def call(data = nil, status_code = 200, content_type = nil)
+      Response.check_header!("Content-Type", content_type) if content_type
       @status_code = status_code
       data = jsonable(data)
       if content_type
         @headers["content-type"] = content_type
-        @body = data.to_s
+        @body = data.is_a?(Hash) || data.is_a?(Array) ? JSON.generate(data) : data.to_s
       elsif data.is_a?(Hash) || data.is_a?(Array)
-        @headers["content-type"] = JSON_CONTENT_TYPE
+        detected_content_type(JSON_CONTENT_TYPE)
         @body = JSON.generate(data)
       else
-        @headers["content-type"] = HTML_CONTENT_TYPE
+        detected_content_type(HTML_CONTENT_TYPE)
         @body = data.to_s
       end
       self
@@ -142,14 +168,16 @@ module Tina4
     end
 
     def csv(content, filename: "export.csv", status: 200)
+      disposition = Response.check_header!("Content-Disposition", "attachment; filename=\"#{filename}\"")
       @status_code = status
       @headers["content-type"] = "text/csv"
-      @headers["content-disposition"] = "attachment; filename=\"#{filename}\""
+      @headers["content-disposition"] = disposition
       @body = content.to_s
       self
     end
 
     def redirect(url, status_or_opts = nil, status: nil)
+      Response.check_header!("Location", url)
       @status_code = status || (status_or_opts.is_a?(Integer) ? status_or_opts : 302)
       @headers["location"] = url
       @body = ""
@@ -157,6 +185,7 @@ module Tina4
     end
 
     def file(path, content_type: nil, download: false, root: nil)
+      Response.check_header!("Content-Type", content_type) if content_type
       # SECURITY: confine the read. The natural spelling of a download route,
       #
       #     response.file("downloads/" + name)   # name = "../secret.env"
@@ -206,7 +235,8 @@ module Tina4
       ext = ::File.extname(path).downcase
       @headers["content-type"] = content_type || MIME_TYPES[ext] || "application/octet-stream"
       if download
-        @headers["content-disposition"] = "attachment; filename=\"#{::File.basename(path)}\""
+        @headers["content-disposition"] =
+          Response.check_header!("Content-Disposition", "attachment; filename=\"#{::File.basename(path)}\"")
       end
       @body = ::File.binread(path)
       self
@@ -279,12 +309,14 @@ module Tina4
       { error: true, code: code, message: message, status: status }
     end
 
-    # Chainable header setter
+    # Chainable header setter. Content-Type (any case) is not a second header:
+    # it replaces the response's one content type, and call(data) keeps it
+    # instead of detecting one (ADR-0072, tina4-python#144).
     def header(name, value = nil)
       if value.nil?
-        @headers[name]
+        @headers[content_type_key?(name) ? "content-type" : name]
       else
-        @headers[name] = value
+        set_header(name, Response.check_header!(name, value))
         self
       end
     end
@@ -294,7 +326,16 @@ module Tina4
       set_cookie(name, value, opts)
     end
 
+    # The value is percent-encoded on the way out, so it can never carry CR,
+    # LF, NUL or ';' to the wire and is not refused (ADR-0068 keeps encoding
+    # where a framework already did). The name and every attribute are refused.
     def set_cookie(name, value, opts = {})
+      label = JSON.generate(name.to_s)
+      raise ArgumentError, "Cookie name must be a valid HTTP token [#{label}]" unless name.to_s.match?(HEADER_TOKEN)
+      if [opts[:path], opts[:same_site], opts[:max_age]].any? { |attribute| attribute.to_s.match?(UNSAFE_COOKIE_CONTENT) }
+        raise ArgumentError, "Invalid character in cookie content [#{label}]"
+      end
+
       cookie_str = "#{name}=#{URI.encode_www_form_component(value)}"
       cookie_str += "; Path=#{opts[:path] || '/'}"
       cookie_str += "; HttpOnly" if opts.fetch(:http_only, true)
@@ -312,7 +353,7 @@ module Tina4
     end
 
     def add_header(key, value)
-      @headers[key] = value
+      set_header(key, Response.check_header!(key, value))
       self
     end
 
@@ -353,6 +394,7 @@ module Tina4
     # @yield [Enumerator::Yielder] Block receives a yielder to push chunks
     # @return [self]
     def stream(generator = nil, content_type: "text/event-stream", &block)
+      Response.check_header!("Content-Type", content_type)
       @status_code = @status_code || 200
       @headers["content-type"] = content_type
       @headers["cache-control"] = "no-cache"
@@ -366,6 +408,7 @@ module Tina4
 
     # Finalize and return the response — matches Python/Node API.
     def send(data = nil, status_code: nil, content_type: nil)
+      Response.check_header!("Content-Type", content_type) if content_type
       if data
         if data.is_a?(Hash) || data.is_a?(Array)
           return json(data, status_code || 200)
@@ -378,6 +421,25 @@ module Tina4
       to_rack
     end
 
+    def content_type_key?(name)
+      name.to_s.casecmp?("content-type")
+    end
+
+    def set_header(name, value)
+      if content_type_key?(name)
+        @headers["content-type"] = value
+        @content_type_from_header = true
+      else
+        @headers[name] = value
+      end
+    end
+
+    # A detected content type never replaces one the route set with header().
+    def detected_content_type(content_type)
+      @headers["content-type"] = content_type unless @content_type_from_header
+    end
+    private :content_type_key?, :set_header, :detected_content_type
+
     def to_rack
       final_headers = @headers.dup
       final_headers["set-cookie"] = @cookies.join("\n") if @cookies && !@cookies.empty?

data/lib/tina4/response_cache.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 module Tina4
   # Multi-backend response cache for GET requests.

data/lib/tina4/router.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "fileutils"
 require "json"

data/lib/tina4/secret_file.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+module Tina4
+  # Internal credential persistence: validate and read/write the same descriptor.
+  module SecretFile
+    def self.update(path)
+      begin
+        before = File.lstat(path)
+        raise IOError, "credential target must be an unlinked regular file" unless before.file? && before.nlink == 1
+      rescue Errno::ENOENT
+        # The O_CREAT open below creates the file with owner-only permissions.
+      end
+      flags = File::RDWR | File::CREAT
+      flags |= File::NOFOLLOW if defined?(File::NOFOLLOW)
+      flags |= File::NONBLOCK if defined?(File::NONBLOCK)
+      File.open(path, flags, 0o600) do |file|
+        file.flock(File::LOCK_EX)
+        stat = file.stat
+        raise IOError, "credential target must be an unlinked regular file" unless stat.file? && stat.nlink == 1
+        file.chmod(0o600)
+        content = yield file.read
+        file.rewind
+        file.truncate(0)
+        file.write(content)
+        file.flush
+      end
+    end
+  end
+end

data/lib/tina4/seeder.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "securerandom"
 require "json"
@@ -856,10 +862,10 @@ module Tina4
         db = ref_class.get_db
         next unless db
 
-        pk = ref_class.primary_key_field || :id
-        rows = db.fetch("SELECT #{pk} FROM #{ref_class.table_name}", [], limit: 100_000)
+        pk_column = ref_class.get_db_column(ref_class.primary_key_field || :id)
+        rows = db.fetch("SELECT #{pk_column} FROM #{ref_class.table_name}", [], limit: 100_000)
         list = rows.respond_to?(:to_a) ? rows.to_a : Array(rows)
-        values = list.map { |r| r[pk] || r[pk.to_s] }.compact
+        values = list.map { |r| r[pk_column] || r[pk_column.to_s] }.compact
         pools[name] = values unless values.empty?
       rescue => e
         Tina4::Log.warning("Seeder: could not resolve FK pool for #{name}: #{e.message}")

data/lib/tina4/service.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 # Tina4 — The Intelligent Native Application 4ramework
-# Copyright 2007 - current Tina4
-# License: MIT https://opensource.org/licenses/MIT
+# Copyright (c) 2026 Code Infinity
+# License: MPL-2.0 https://mozilla.org/MPL/2.0/
 
 module Tina4
   # Base class for class-based background services managed by

data/lib/tina4/service_runner.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 module Tina4
   # Context object passed to each service handler, giving it control

data/lib/tina4/session.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "securerandom"
 require "json"
 

data/lib/tina4/session_handlers/database_handler.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "json"
 

data/lib/tina4/session_handlers/file_handler.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 require "fileutils"
 require "digest"

data/lib/tina4/session_handlers/memcached_handler.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "digest"
 require "json"

data/lib/tina4/session_handlers/mongo_handler.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 require_relative "mongo_wire_client"
 
@@ -51,36 +57,90 @@ module Tina4
         @database = options[:database] || ENV["TINA4_SESSION_MONGO_DB"] || "tina4"
         @collection_name = options[:collection] || ENV["TINA4_SESSION_MONGO_COLLECTION"] || "sessions"
         @gem_available = gem_available?
-        @client = nil
-        @wire_client = nil
-        @collection = nil
-        @index_ready = false
       end
 
-      # Release whichever transport was opened.
+      # ONE TRANSPORT PER PROCESS (issue #136, parity with tina4-python #136).
       #
-      # Mongo::Client owns a pool of REAL sockets. Before the client was lazy it
-      # was a local variable in #initialize, reachable only through the
-      # collection, so every construction leaked a pool and nothing could give it
-      # back. Now the handler holds the client, so the handler can close it -
-      # parity with the Python master's MongoDBSessionHandler.close() and with
-      # Tina4::DocStore.close_doc_store, which already closes its Mongo clients
-      # the same way. The zero-dependency transport owns ONE raw socket and is
-      # closed the same way, so neither path leaks. Safe to call on a handler
-      # that never connected.
-      def close
-        # Each close is guarded on its own: a failure on one transport must not
-        # skip the other, and neither may mask the caller's work.
-        [@client, @wire_client].each do |transport|
+      # Every request builds a Session and every Session builds a NEW handler,
+      # so a transport owned by the handler is a transport per REQUEST. The
+      # handler used to open its own Mongo::Client on first use - each with its
+      # own SDAM monitor threads and connection pool - and nothing ever closed
+      # it. MEASURED on the lab: 21 requests left 87 extra threads behind; on the
+      # zero-dependency path 40 sessions left 40 sockets open to MongoDB.
+      #
+      # A Mongo::Client is thread-safe and pools internally, so the driver
+      # expects exactly one per (uri, database) - the same shape
+      # Tina4::DocStore.mongo_client already uses. The zero-dependency
+      # MongoWireClient is bound to one collection and serialises its commands
+      # on its single socket, so it is shared per (uri, database, collection).
+      # Handlers hold no transport of their own: they look it up here on every
+      # operation, so a released transport is simply rebuilt on next use.
+      @shared = {}
+      @index_ready = {}
+      @shared_lock = Mutex.new
+
+      class << self
+        # The shared transport for +key+, built by the block on first use. The
+        # double-checked lock stops two threads racing the first request from
+        # both building a client and orphaning one - the same leak, just rarer.
+        def shared_transport(key)
+          transport = @shared[key]
+          return transport if transport
+
+          @shared_lock.synchronize { @shared[key] ||= yield }
+        end
+
+        # True exactly once per process for +key+ - used so the TTL index round
+        # trip runs once per (store, ttl), not once per request.
+        def claim_index(key)
+          @shared_lock.synchronize do
+            next false if @index_ready[key]
+
+            @index_ready[key] = true
+          end
+        end
+
+        # Close and forget the shared transport for +key+ (MongoHandler#close).
+        def release_shared(key)
+          close_transport(@shared_lock.synchronize { @shared.delete(key) })
+        end
+
+        # Close every shared session transport - process shutdown, or a test
+        # that must leave no connection behind. Safe to call at any time: the
+        # next session operation simply reconnects.
+        def close_shared_clients
+          transports = @shared_lock.synchronize do
+            values = @shared.values
+            @shared.clear
+            @index_ready.clear
+            values
+          end
+          transports.each { |transport| close_transport(transport) }
+          true
+        end
+
+        private
+
+        # A close failure must never mask the caller's work.
+        def close_transport(transport)
           transport&.close
         rescue StandardError
           nil
         end
-      ensure
-        @client = nil
-        @wire_client = nil
-        @collection = nil
-        @index_ready = false
+      end
+
+      # Release the transport this handler's configuration uses.
+      #
+      # The transport is SHARED per process (see .shared_transport), so this
+      # closes it for every handler pointed at the same store - exactly what an
+      # owner that is done with the store wants, and harmless to the rest: they
+      # look the transport up on every operation and reconnect on next use. The
+      # Mongo::Client (a pool of real sockets) and the zero-dependency socket
+      # are both closed this way, so neither path leaks. Safe to call on a
+      # handler that never connected. Parity with the Python master's
+      # MongoDBSessionHandler.close() and Tina4::DocStore.close_doc_store.
+      def close
+        self.class.release_shared(transport_key)
       end
 
       # Decide whether a stored document has expired, FROM THE DOCUMENT ALONE.
@@ -189,17 +249,25 @@ module Tina4
       # handler takes the other. A per-operation branch is a branch that can be
       # wrong on one path only - which is exactly how a fallback ships untested.
       def collection
-        return @collection if @collection
+        if @gem_available
+          client = self.class.shared_transport(transport_key) { Mongo::Client.new(@uri, database: @database) }
+          collection = client[@collection_name]
+          ensure_ttl_index(collection)
+          collection
+        else
+          self.class.shared_transport(transport_key) { build_wire_client }
+        end
+      end
 
+      # The registry key for this handler's transport: one Mongo::Client per
+      # (uri, database); one wire client per (uri, database, collection), since
+      # a MongoWireClient is bound to a single collection.
+      def transport_key
         if @gem_available
-          @client = Mongo::Client.new(@uri, database: @database)
-          @collection = @client[@collection_name]
-          ensure_ttl_index
+          [:gem, @uri, @database]
         else
-          @wire_client = build_wire_client
-          @collection = @wire_client
+          [:wire, @uri, @database, @collection_name]
         end
-        @collection
       end
 
       # The zero-dependency transport, pointed at the host and port parsed out of
@@ -258,18 +326,19 @@ module Tina4
       # does not exist when the gem is absent, so evaluating them would raise
       # NameError rather than the LoadError anyone would expect.
       #
-      # Runs ONCE per handler (@index_ready), on the first operation. The flag is
-      # set BEFORE the round trip so an unreachable server is not re-probed on
-      # every read - the same ordering the Python master uses for _table_ready.
-      def ensure_ttl_index
-        return if @index_ready
+      # Runs ONCE per process for each (store, collection, ttl), on the first
+      # operation - not once per handler, which is once per REQUEST (issue
+      # #136). The claim is taken BEFORE the round trip so an unreachable server
+      # is not re-probed on every read - the same ordering the Python master
+      # uses for _table_ready.
+      def ensure_ttl_index(collection)
+        return unless self.class.claim_index([@uri, @database, @collection_name, @ttl])
 
-        @index_ready = true
-        @collection.indexes.create_one({ updated_at: 1 }, expire_after_seconds: @ttl)
+        collection.indexes.create_one({ updated_at: 1 }, expire_after_seconds: @ttl)
       rescue Mongo::Error::OperationFailure => e
         raise unless e.code == 85 || e.message.include?("IndexOptionsConflict")
-        @collection.indexes.drop_one("updated_at_1")
-        @collection.indexes.create_one({ updated_at: 1 }, expire_after_seconds: @ttl)
+        collection.indexes.drop_one("updated_at_1")
+        collection.indexes.create_one({ updated_at: 1 }, expire_after_seconds: @ttl)
       rescue Mongo::Error => e
         # The index is the background REAPER, not the expiry authority - #read
         # checks expires_at on the document itself - so failing to create it must

data/lib/tina4/session_handlers/mongo_wire_client.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "socket"
 
@@ -71,6 +77,10 @@ module Tina4
         @timeout = timeout
         @socket = nil
         @request_id = 0
+        # One socket carries one request/reply at a time. The client is SHARED
+        # by every session in the process (MongoHandler.shared_transport, issue
+        # #136), so concurrent requests must not interleave their frames.
+        @lock = Mutex.new
       end
 
       # Documents matching +filter+, capped at one.
@@ -142,15 +152,19 @@ module Tina4
       # transport failure, so the socket is dropped and the next command
       # reconnects rather than inheriting the damage.
       def exchange(document)
-        socket = connection
-        @request_id += 1
-        body = "\x00\x00\x00\x00".b + "\x00".b + encode_document(document) # flagBits(4) + section kind 0
-        header = [16 + body.bytesize, @request_id, 0, OP_MSG].pack("V4")
-        socket.write(header + body)
-        read_reply(socket)
-      rescue StandardError => e
-        close
-        raise MongoWireError, "MongoDB transport failed: #{e.message}"
+        @lock.synchronize do
+          socket = connection
+          @request_id += 1
+          body = "\x00\x00\x00\x00".b + "\x00".b + encode_document(document) # flagBits(4) + section kind 0
+          header = [16 + body.bytesize, @request_id, 0, OP_MSG].pack("V4")
+          socket.write(header + body)
+          read_reply(socket)
+        rescue StandardError => e
+          # Still under the lock: no other session can be mid-exchange on the
+          # socket being dropped. The next command reconnects.
+          close
+          raise MongoWireError, "MongoDB transport failed: #{e.message}"
+        end
       end
 
       def connection

data/lib/tina4/session_handlers/redis_handler.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 require_relative "resp_client"
 

data/lib/tina4/session_handlers/resp_client.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 
 require "socket"
 

data/lib/tina4/session_handlers/valkey_handler.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
+# Copyright (c) 2026 Code Infinity
+# SPDX-License-Identifier: MPL-2.0
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
 require "json"
 require_relative "resp_client"