tina4ruby 3.13.137 → 3.13.139

data/lib/tina4/request.rb

@@ -1,8 +1,16 @@
 # 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 "uri"
 require "json"
 require "ipaddr"
 require "stringio"
+require_relative "parse_json"
+require_relative "form_parser"
 
 module Tina4
   # A Hash subclass that supports indifferent access (both string and symbol keys).
@@ -122,24 +130,36 @@ module Tina4
     # reads route.auth_required to honour a public write route (.no_auth).
     attr_accessor :user, :route
 
-    # Maximum upload size in bytes (default 10 MB). Override via TINA4_MAX_UPLOAD_SIZE env var.
-    TINA4_MAX_UPLOAD_SIZE = Integer(ENV.fetch("TINA4_MAX_UPLOAD_SIZE", 10_485_760))
+    # Default upload cap in bytes (10 MB). The live cap is max_upload_size, which
+    # reads TINA4_MAX_UPLOAD_SIZE when it is used (ADR-0072). This constant used
+    # to read the environment at require time, which raised on a bad value.
+    TINA4_MAX_UPLOAD_SIZE = 10_485_760
 
     class PayloadTooLarge < StandardError; end
 
     # Effective upload cap in bytes. Read at CALL TIME (not frozen into the
     # constant at load) so the limit honours a TINA4_MAX_UPLOAD_SIZE set after
     # this file was required, and so a test can lower it. Falls back to the
-    # constant default when the env var is unset/blank.
+    # constant default when the env var is unset/blank. A value that is not a
+    # positive whole number warns once and uses the default (ADR-0068): to_i
+    # used to turn "abc" into 0, which refused every request with a body.
     def self.max_upload_size
-      value = ENV["TINA4_MAX_UPLOAD_SIZE"]
-      value.nil? || value.empty? ? TINA4_MAX_UPLOAD_SIZE : value.to_i
+      raw = ENV["TINA4_MAX_UPLOAD_SIZE"].to_s.strip
+      return TINA4_MAX_UPLOAD_SIZE if raw.empty?
+      return raw.to_i if raw.match?(/\A\d+\z/) && raw.to_i.positive?
+
+      @warned_upload_limits ||= {}
+      unless @warned_upload_limits[raw]
+        @warned_upload_limits[raw] = true
+        Tina4::Log.warning("TINA4_MAX_UPLOAD_SIZE=#{raw} is not a usable limit - using #{TINA4_MAX_UPLOAD_SIZE}")
+      end
+      TINA4_MAX_UPLOAD_SIZE
     end
 
     # Read an IO in bounded chunks, raising PayloadTooLarge the MOMENT the
     # running total exceeds the upload cap, so an over-limit body is refused as
     # it arrives instead of after the whole thing is buffered. Rewinds the input
-    # before and after so a later reader (Rack's parser, form-token extraction)
+    # before and after so a later reader (the form parser, form-token extraction)
     # sees the same stream. Parity with the Python/Node per-chunk body readers.
     def self.read_stream_capped(input, limit = nil)
       return "" unless input
@@ -258,7 +278,7 @@ module Tina4
     # @return [Boolean] true when the client's scheme is https.
     def self.secure_scheme?(env)
       forwarded = (env["HTTP_X_FORWARDED_PROTO"] || "").to_s
-      unless forwarded.strip.empty?
+      if Tina4.trusted_proxy?(env["REMOTE_ADDR"].to_s) && !forwarded.strip.empty?
         return forwarded.split(",").first.to_s.strip.casecmp("https").zero?
       end
       scheme = (env["rack.url_scheme"] || "").to_s
@@ -272,7 +292,13 @@ module Tina4
     # still see the URL the client used. Matches Python/PHP/Node parity.
     def url
       scheme = self.class.secure_scheme?(env) ? "https" : "http"
-      host = env["HTTP_X_FORWARDED_HOST"] || env["HTTP_HOST"] || env["SERVER_NAME"] || "localhost"
+      # X-Forwarded-Host is honoured ONLY when the raw socket peer is a trusted
+      # proxy (TINA4_TRUSTED_PROXIES) — the same gate already applied to
+      # X-Forwarded-For. An untrusted client can otherwise forge the host and
+      # control the absolute request.url (password-reset links, cache keys,
+      # open-redirect base). Parity with Python/PHP/Node.
+      forwarded_host = Tina4.trusted_proxy?(@remote_ip) ? env["HTTP_X_FORWARDED_HOST"] : nil
+      host = forwarded_host || env["HTTP_HOST"] || env["SERVER_NAME"] || "localhost"
       port = env["SERVER_PORT"]
       url_str = "#{scheme}://#{host}"
       # Only append :port when the host doesn't already include one
@@ -395,7 +421,7 @@ module Tina4
 
     def json_body
       @json_body ||= begin
-        JSON.parse(body_raw)
+        Tina4.parse_json(body_raw)
       rescue JSON::ParserError, TypeError
         {}
       end
@@ -474,36 +500,47 @@ module Tina4
       data
     end
 
-    # Resolve the parsed multipart form fields (+ file entries) for this request.
+    # The parsed multipart body, memoised: { fields:, files:, error: } from
+    # Tina4::FormParser, or nil when there is no raw body to parse.
     #
-    # A live Rack server (Puma/WEBrick) does NOT parse the request body for us -
-    # it hands the app the raw `rack.input` stream. `Rack::Request#POST` parses
-    # a multipart (or urlencoded) body and caches the result into the standard
-    # `rack.request.form_hash` env key, which both #parse_body and #extract_files
-    # then read. We only invoke it when the key isn't already populated, so a
-    # spec that injects `rack.request.form_hash` directly still short-circuits
-    # here (and we never re-parse a body twice). Without this, live multipart
-    # uploads arrived empty (fields AND files) - the parse only ran in specs.
+    # A live server hands the app the raw `rack.input` stream and parses nothing,
+    # so Tina4 parses it here. The body is read through read_stream_capped, so the
+    # running upload cap refuses an over-limit body as it arrives - OUTSIDE any
+    # rescue on purpose: PayloadTooLarge must reach the 413 handler.
+    def multipart_parsed
+      return @multipart_parsed if defined?(@multipart_parsed)
+
+      body = Tina4::Request.read_stream_capped(@env["rack.input"])
+      @multipart_parsed =
+        if body.nil? || body.empty?
+          nil
+        else
+          parsed = Tina4::FormParser.parse_multipart(body, @content_type)
+          if parsed[:error] && defined?(Tina4::Log)
+            Tina4::Log.warning("multipart parse failed: #{parsed[:error].message}")
+          end
+          parsed
+        end
+    end
+
+    # The request's form hash: fields plus file entries under the standard
+    # `rack.request.form_hash` env key, the same key (and shape) Rack::Request#POST
+    # used to fill, so middleware reading it keeps working. A spec or middleware
+    # that INJECTS the key short-circuits the parse entirely.
     def multipart_form_hash
       existing = @env["rack.request.form_hash"] rescue nil
       return existing if existing
 
-      # Enforce the running per-chunk upload cap BEFORE Rack reads the body, so
-      # an over-limit body is refused as it arrives rather than after Rack has
-      # buffered the whole thing. Outside the begin/rescue below on purpose: the
-      # PayloadTooLarge must propagate to the 413 handler, not be swallowed.
-      Tina4::Request.read_stream_capped(@env["rack.input"])
-
-      parsed = begin
-        require "rack"
-        Rack::Request.new(@env).POST
-      rescue Tina4::Request::PayloadTooLarge
-        raise
-      rescue StandardError => e
-        Tina4::Log.warning("multipart parse failed: #{e.message}") if defined?(Tina4::Log)
-        nil
+      parsed = multipart_parsed
+      return nil unless parsed
+
+      form = parsed[:fields].dup
+      parsed[:files].each do |name, list|
+        # Rack left an empty file field (filename="") out of the form hash.
+        kept = list.reject { |descriptor| descriptor[:filename].empty? }
+        form[name] = kept.length == 1 ? kept.first : kept unless kept.empty?
       end
-      @env["rack.request.form_hash"] || parsed
+      @env["rack.request.form_hash"] = form
     end
 
     def parse_body
@@ -521,14 +558,14 @@ module Tina4
         # NOT delegating to #json_body: that method keeps its own documented
         # always-a-Hash, {}-on-failure contract for direct callers.
         begin
-          JSON.parse(body_raw)
+          Tina4.parse_json(body_raw)
         rescue JSON::ParserError, TypeError
           body_raw
         end
       elsif @content_type.include?("application/x-www-form-urlencoded")
         parse_query_to_hash(body_raw)
       elsif @content_type.include?("multipart/form-data")
-        # Extract form fields from Rack's parsed multipart data.
+        # Form fields from the parsed multipart body (Tina4::FormParser).
         # Files are handled separately by extract_files.
         result = {}
         form_hash = multipart_form_hash
@@ -560,38 +597,27 @@ module Tina4
     def extract_files
       result = {}
       return result unless @content_type.include?("multipart/form-data")
-      begin
-        # LIVE path: hand-scan the raw body so a REPEATED file field name is
-        # preserved as a LIST (Rack's POST collapses a repeated non-bracket name
-        # to last-wins - the multi-file data-loss this fixes). The scan reads the
-        # body through the capped reader, so an over-limit upload is refused as
-        # it arrives. Falls through to the parsed form_hash when there is no raw
-        # body (e.g. a spec injecting rack.request.form_hash).
-        scanned = scan_multipart_files
-        if scanned && !scanned.empty?
-          scanned.each do |key, list|
-            files = list.map { |value| build_file_upload(value) }.compact
-            result[key] = files.length == 1 ? files.first : files unless files.empty?
-          end
-          return result
-        end
 
-        form_hash = multipart_form_hash
-        if form_hash
-          form_hash.each do |key, value|
-            if value.is_a?(Array)
-              files = value.map { |v| build_file_upload(v) }.compact
-              result[key] = files.length == 1 ? files.first : files unless files.empty?
-            else
-              file = build_file_upload(value)
-              result[key] = file if file
-            end
+      # LIVE path: the parser keeps a REPEATED file field name as a LIST (Rack's
+      # POST collapsed a repeated non-bracket name to last-wins - the multi-file
+      # data loss). Falls through to an injected rack.request.form_hash when
+      # there is no raw body to parse.
+      injected = @env["rack.request.form_hash"] unless multipart_parsed
+      if multipart_parsed
+        multipart_parsed[:files].each do |key, list|
+          files = list.map { |value| build_file_upload(value) }.compact
+          result[key] = files.length == 1 ? files.first : files unless files.empty?
+        end
+      elsif injected
+        injected.each do |key, value|
+          if value.is_a?(Array)
+            files = value.map { |v| build_file_upload(v) }.compact
+            result[key] = files.length == 1 ? files.first : files unless files.empty?
+          else
+            file = build_file_upload(value)
+            result[key] = file if file
           end
         end
-      rescue Tina4::Request::PayloadTooLarge
-        raise
-      rescue StandardError
-        # Multipart parsing failed
       end
       result
     end
@@ -612,68 +638,5 @@ module Tina4
       file["content"] = value[:content] if value.key?(:content) && !value[:content].nil?
       file
     end
-
-    # Extract the boundary token from a multipart Content-Type header.
-    def multipart_boundary(content_type)
-      content_type.to_s.split(";").each do |part|
-        part = part.strip
-        next unless part.start_with?("boundary=")
-
-        return part[9..].to_s.delete_prefix('"').delete_suffix('"')
-      end
-      nil
-    end
-
-    # Hand-roll the FILE parts out of the raw multipart body, keyed by field
-    # name, each name mapping to a LIST of descriptors so a repeated name keeps
-    # every file. Reads through read_stream_capped, so the running per-chunk
-    # upload cap is enforced here too (raising PayloadTooLarge). Returns {} when
-    # there is no raw body (the injected-form_hash path is used instead). Fields
-    # are handled by parse_body (via Rack) - this scans files only.
-    def scan_multipart_files
-      boundary = multipart_boundary(@content_type)
-      return {} unless boundary
-
-      body = Tina4::Request.read_stream_capped(@env["rack.input"])
-      return {} if body.nil? || body.empty?
-
-      body = body.dup.force_encoding("BINARY")
-      files = {}
-      delimiter = "--#{boundary}"
-      body.split(delimiter).each do |segment|
-        next if segment.empty? || segment.start_with?("--")
-
-        segment = segment.sub(/\A\r\n/, "")
-        header_end = segment.index("\r\n\r\n")
-        next unless header_end
-
-        header_section = segment[0...header_end]
-        content = segment[(header_end + 4)..] || ""
-        content = content.sub(/\r\n\z/, "")
-
-        name = nil
-        filename = nil
-        type = "application/octet-stream"
-        header_section.split("\r\n").each do |line|
-          if line =~ /content-disposition/i
-            name = Regexp.last_match(1) if line =~ /name="([^"]*)"/
-            filename = Regexp.last_match(1) if line =~ /filename="([^"]*)"/
-          elsif line =~ /content-type:\s*(.+)/i
-            type = Regexp.last_match(1).strip
-          end
-        end
-        next if name.nil? || filename.nil?
-
-        bytes = content.dup.force_encoding("BINARY")
-        (files[name] ||= []) << {
-          filename: filename,
-          type: type,
-          content: bytes,
-          size: bytes.bytesize,
-          tempfile: StringIO.new(bytes)
-        }
-      end
-      files
-    end
   end
 end

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"