tina4ruby 3.13.137 → 3.13.138

data/lib/tina4/dev_admin.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 "digest"
@@ -10,6 +16,8 @@ require "shellwords"
 require "rbconfig" # RbConfig.ruby for scaffold_run's Open3.capture3 call to exe/tina4ruby
 require "open3"    # scaffold_run shells to exe/tina4ruby generate <kind> <name>
 require_relative "metrics"
+require_relative "parse_json"
+require_relative "secret_file"
 
 module Tina4
   # Thread-safe in-memory message log for dev dashboard
@@ -385,8 +393,10 @@ module Tina4
         path = env["PATH_INFO"] || "/"
         method = env["REQUEST_METHOD"]
 
+        # ADR-0082: ONE gate for every /__dev request, reads and writes alike -
+        # Host allow-list (DNS rebinding), same-origin, loopback peer.
         # DEVADMIN-DEC-01/02 (feature 127): fail-closed same-origin + loopback
-        # gate on every /__dev write, before ANY handler runs. Closes drive-by
+        # gate on every /__dev request, before ANY handler runs. Closes drive-by
         # CSRF (a page the developer also has open POSTing to /file/save then
         # /reload) and a network-exposed debug box. GET/HEAD/OPTIONS skip it;
         # the MCP surface keeps its own richer 404 gate (with_mcp_gate), so the
@@ -562,7 +572,8 @@ module Tina4
         case [method, path]
         when ["GET", "/__dev/api/table"]
           table_name = query_param(env, "name")
-          json_response(table_detail_payload(table_name))
+          payload = table_detail_payload(table_name)
+          json_response(payload.except(:status), payload[:status] || 200)
         when ["POST", "/__dev/api/seed"]
           handle_seed(env)
         when ["POST", "/__dev/api/tool"]
@@ -629,18 +640,22 @@ module Tina4
           rel = query_param(env, "path")
           # DEVADMIN-DEC-03: a secret path refuses with 403 (parity with Python);
           # file_read_payload also guards so the body never carries the content.
-          json_response(file_read_payload(rel), secret_path?(rel) ? 403 : 200)
+          # ADR-0082: judged on the RESOLVED path too; a path outside the
+          # project is refused 403 like Python.
+          payload = file_read_payload(rel)
+          refused = secret_path?(rel) || resolved_secret?(rel) || payload[:error].to_s.include?("escapes project")
+          json_response(payload, refused ? 403 : 200)
         when ["GET", "/__dev/api/file/raw"]
           file_raw_response(query_param(env, "path"))
         when ["POST", "/__dev/api/file/save"]
           body = read_json_body(env) || {}
-          json_response(file_save(body))
+          file_op_response(file_save(body))
         when ["POST", "/__dev/api/file/rename"]
           body = read_json_body(env) || {}
-          json_response(file_rename(body))
+          file_op_response(file_rename(body))
         when ["POST", "/__dev/api/file/delete"]
           body = read_json_body(env) || {}
-          json_response(file_delete(body))
+          file_op_response(file_delete(body))
         when ["GET", "/__dev/api/deps/search"]
           json_response(deps_search(query_param(env, "q") || query_param(env, "query") || ""))
         when ["POST", "/__dev/api/deps/install"]
@@ -801,7 +816,21 @@ module Tina4
       # (503).
       def metrics_file_response(env)
         file_path = (query_param(env, "path") || "").to_s
-        json_response(Tina4::Metrics.file_detail(file_path))
+        # ADR-0082: the path must resolve inside the project or the last scan
+        # root; an absolute path elsewhere is refused before the engine runs.
+        scan_root = Tina4::Metrics.instance_variable_get(:@last_scan_root)
+        resolved = begin
+          safe_project_path(file_path, extra_roots: [scan_root])
+        rescue ArgumentError
+          begin
+            scan_root ? safe_project_path(File.join(scan_root, file_path), extra_roots: [scan_root]) : nil
+          rescue ArgumentError
+            nil
+          end
+        end
+        return json_response({ "error" => "Path outside project" }, 403) if !file_path.empty? && resolved.nil?
+
+        json_response(Tina4::Metrics.file_detail(file_path.empty? ? file_path : resolved))
       rescue Tina4::MetricsEngineError => e
         bad_path = e.message.include?("no such file") ||
                    e.message.include?("not a file") ||
@@ -834,7 +863,7 @@ module Tina4
         input.rewind if input.respond_to?(:rewind)
         raw = input.read
         return nil if raw.nil? || raw.empty?
-        JSON.parse(raw) rescue nil
+        Tina4.parse_json(raw) rescue nil
       end
 
       def json_response(data, status = 200)
@@ -869,7 +898,7 @@ module Tina4
             return { current: current, latest: nil,
                      error: "RubyGems answered #{resp.code}" }
           end
-          latest = JSON.parse(resp.body)["version"]
+          latest = Tina4.parse_json(resp.body)["version"]
           # Reaching RubyGems is not the same as learning the version: an
           # answer with none in it is the same lie by another route.
           if latest.nil? || latest.to_s.empty?
@@ -987,7 +1016,7 @@ module Tina4
             limit: "N/A"
           },
           server: {
-            software: "Ruby/WEBrick",
+            software: "Ruby/#{Tina4::HttpServer::SOFTWARE}",
             hostname: host_name,
             document_root: Tina4.root_dir || Dir.pwd
           },
@@ -1149,20 +1178,22 @@ module Tina4
       def grounding_token_save(body)
         token = (body && body["token"]).to_s.strip
         env_path = File.join(Dir.pwd, ".env")
-        lines = File.file?(env_path) ? File.readlines(env_path, chomp: true) : []
-        found = false
-        new_lines = lines.map do |line|
-          stripped = line.strip
-          if !stripped.empty? && !stripped.start_with?("#") && stripped.include?("=") &&
-             stripped.split("=", 2).first.strip == "TINA4_MCP_TOKEN"
-            found = true
-            "TINA4_MCP_TOKEN=#{token}"
-          else
-            line
+        SecretFile.update(env_path) do |content|
+          lines = content.lines(chomp: true)
+          found = false
+          new_lines = lines.map do |line|
+            stripped = line.strip
+            if !stripped.empty? && !stripped.start_with?("#") && stripped.include?("=") &&
+               stripped.split("=", 2).first.strip == "TINA4_MCP_TOKEN"
+              found = true
+              "TINA4_MCP_TOKEN=#{token}"
+            else
+              line
+            end
           end
+          new_lines << "TINA4_MCP_TOKEN=#{token}" unless found
+          new_lines.join("\n") + "\n"
         end
-        new_lines << "TINA4_MCP_TOKEN=#{token}" unless found
-        File.write(env_path, new_lines.join("\n") + "\n")
 
         if token.empty?
           ENV.delete("TINA4_MCP_TOKEN")
@@ -1432,8 +1463,17 @@ module Tina4
         return { error: "No database configured" } unless db
 
         begin
+          # ADR-0082: only a name the database itself reports is accepted, and
+          # it is quoted as an identifier - never spliced raw into SQL.
+          return { error: "unknown table", status: 404 } unless Array(db.tables).map(&:to_s).include?(table_name)
+
+          quoted = if db.respond_to?(:driver_name) && db.driver_name.to_s.include?("mysql")
+                     "`#{table_name.gsub('`', '``')}`"
+                   else
+                     "\"#{table_name.gsub('"', '""')}\""
+                   end
           columns = db.columns(table_name)
-          result = db.fetch("SELECT * FROM #{table_name} LIMIT 20")
+          result = db.fetch("SELECT * FROM #{quoted}", [], limit: 20)
           rows = result.respond_to?(:to_a) ? result.to_a : (result.is_a?(Array) ? result : [])
           { table: table_name, columns: columns, rows: rows, count: rows.size }
         rescue => e
@@ -1558,45 +1598,47 @@ module Tina4
         return json_response({ success: false, error: "No connection URL provided" }) if url.empty?
         begin
           env_path = File.join(Dir.pwd, ".env")
-          lines = File.file?(env_path) ? File.readlines(env_path, chomp: true) : []
-          # v3.12+ env vars are TINA4_-prefixed; saving bare DATABASE_URL
-          # would trip the framework's legacy-env boot guard on next start.
-          keys_found = {
-            "TINA4_DATABASE_URL" => false,
-            "TINA4_DATABASE_USERNAME" => false,
-            "TINA4_DATABASE_PASSWORD" => false,
-          }
-          new_lines = []
-          lines.each do |line|
-            stripped = line.strip
-            if stripped.empty? || stripped.start_with?("#") || !stripped.include?("=")
-              new_lines << line
-              next
+          SecretFile.update(env_path) do |content|
+            lines = content.lines(chomp: true)
+            # v3.12+ env vars are TINA4_-prefixed; saving bare DATABASE_URL
+            # would trip the framework's legacy-env boot guard on next start.
+            keys_found = {
+              "TINA4_DATABASE_URL" => false,
+              "TINA4_DATABASE_USERNAME" => false,
+              "TINA4_DATABASE_PASSWORD" => false,
+            }
+            new_lines = []
+            lines.each do |line|
+              stripped = line.strip
+              if stripped.empty? || stripped.start_with?("#") || !stripped.include?("=")
+                new_lines << line
+                next
+              end
+              key = stripped.split("=", 2).first.strip
+              case key
+              when "TINA4_DATABASE_URL"
+                new_lines << "TINA4_DATABASE_URL=#{url}"
+                keys_found["TINA4_DATABASE_URL"] = true
+              when "TINA4_DATABASE_USERNAME"
+                new_lines << "TINA4_DATABASE_USERNAME=#{username}"
+                keys_found["TINA4_DATABASE_USERNAME"] = true
+              when "TINA4_DATABASE_PASSWORD"
+                new_lines << "TINA4_DATABASE_PASSWORD=#{password}"
+                keys_found["TINA4_DATABASE_PASSWORD"] = true
+              else
+                new_lines << line
+              end
             end
-            key = stripped.split("=", 2).first.strip
-            case key
-            when "TINA4_DATABASE_URL"
-              new_lines << "TINA4_DATABASE_URL=#{url}"
-              keys_found["TINA4_DATABASE_URL"] = true
-            when "TINA4_DATABASE_USERNAME"
-              new_lines << "TINA4_DATABASE_USERNAME=#{username}"
-              keys_found["TINA4_DATABASE_USERNAME"] = true
-            when "TINA4_DATABASE_PASSWORD"
-              new_lines << "TINA4_DATABASE_PASSWORD=#{password}"
-              keys_found["TINA4_DATABASE_PASSWORD"] = true
-            else
-              new_lines << line
+            values = {
+              "TINA4_DATABASE_URL" => url,
+              "TINA4_DATABASE_USERNAME" => username,
+              "TINA4_DATABASE_PASSWORD" => password,
+            }
+            keys_found.each do |key, found|
+              new_lines << "#{key}=#{values[key]}" unless found
             end
+            new_lines.join("\n") + "\n"
           end
-          values = {
-            "TINA4_DATABASE_URL" => url,
-            "TINA4_DATABASE_USERNAME" => username,
-            "TINA4_DATABASE_PASSWORD" => password,
-          }
-          keys_found.each do |key, found|
-            new_lines << "#{key}=#{values[key]}" unless found
-          end
-          File.write(env_path, new_lines.join("\n") + "\n")
           json_response({ success: true })
         rescue => e
           json_response({ success: false, error: e.message })
@@ -1656,13 +1698,39 @@ module Tina4
         { deployed: name, files: copied }
       end
 
-      def safe_project_path(rel_path)
-        root = File.expand_path(Dir.pwd)
-        resolved = File.expand_path(rel_path.to_s, root)
-        raise ArgumentError, "path escapes project directory" unless resolved.start_with?(root)
+      # ADR-0082: resolve the path the way the OS will open it (".." collapsed,
+      # symlinks followed on the deepest existing part) and require it inside an
+      # allowed root, with a trailing separator so /app never contains /app-x.
+      def safe_project_path(rel_path, extra_roots: [])
+        root = real_path_of(File.expand_path(Dir.pwd))
+        resolved = real_path_of(File.expand_path(rel_path.to_s, root))
+        roots = [root] + extra_roots.compact.map { |r| real_path_of(File.expand_path(r.to_s)) }
+        unless roots.any? { |r| resolved == r || resolved.start_with?(r.chomp("/") + "/") }
+          raise ArgumentError, "path escapes project directory"
+        end
         resolved
       end
 
+      # Real path of +path+: the deepest existing ancestor is realpath'd and the
+      # not-yet-existing tail (a new file being saved) is appended.
+      def real_path_of(path)
+        existing = path
+        tail = []
+        until File.exist?(existing) || File.symlink?(existing) || existing == File.dirname(existing)
+          tail.unshift(File.basename(existing))
+          existing = File.dirname(existing)
+        end
+        File.join(File.realpath(existing), *tail)
+      rescue SystemCallError
+        path
+      end
+
+      # Project-relative form of a resolved path, for the secret denylist.
+      def project_relative(resolved)
+        root = real_path_of(File.expand_path(Dir.pwd))
+        resolved == root ? "" : resolved.delete_prefix(root.chomp("/") + "/")
+      end
+
       # Noise dirs + hidden dot-entries are hidden from the file browser,
       # except the env files — verbatim parity with PHP/Python dev-admin.
       DEV_FILES_IGNORED = %w[__pycache__ node_modules vendor .git venv .venv dist target .tina4].freeze
@@ -1812,20 +1880,32 @@ module Tina4
         ext_map.fetch(File.extname(base).downcase, "text")
       end
 
+      # Validate and read one descriptor; never reopen a checked pathname.
+      def read_project_bytes(target)
+        flags = File::RDONLY
+        flags |= File::NOFOLLOW if defined?(File::NOFOLLOW)
+        flags |= File::NONBLOCK if defined?(File::NONBLOCK)
+        File.open(target, flags) do |file|
+          file.binmode
+          info = file.stat
+          raise ArgumentError, "Not a regular file" unless info.file?
+          file.read || "".b
+        end
+      end
+
       def file_read_payload(rel)
         return { error: "path required" } if rel.nil? || rel.empty?
         # DEVADMIN-DEC-03: never serve secret material (.env, keys, secrets/).
         # The dispatch statuses this 403; the guard here keeps the helper safe
         # for any other caller too. The secret content never enters the payload.
-        if secret_path?(rel)
+        if secret_path?(rel) || resolved_secret?(rel)
           return { error: "Refused: secret file", path: rel.to_s, content: "", language: "text", bytes: 0 }
         end
         begin
           target = safe_project_path(rel)
-          return { error: "Not found" } unless File.exist?(target)
-          return { error: "Not a file" } unless File.file?(target)
-          content = File.read(target, encoding: "utf-8", invalid: :replace, undef: :replace)
-          { path: rel, content: content, bytes: File.size(target), language: dev_admin_language(rel) }
+          data = read_project_bytes(target)
+          content = data.dup.force_encoding(Encoding::UTF_8).scrub
+          { path: rel, content: content, bytes: data.bytesize, language: dev_admin_language(rel) }
         rescue => e
           { error: e.message }
         end
@@ -1834,11 +1914,10 @@ module Tina4
       def file_raw_response(rel)
         return json_response({ error: "path required" }) if rel.nil? || rel.empty?
         # DEVADMIN-DEC-03: never serve secret material (.env, keys, secrets/).
-        return json_response({ error: "Refused: secret file" }, 403) if secret_path?(rel)
+        return json_response({ error: "Refused: secret file" }, 403) if secret_path?(rel) || resolved_secret?(rel)
         begin
           target = safe_project_path(rel)
-          return json_response({ error: "Not found" }) unless File.file?(target)
-          content = File.binread(target)
+          content = read_project_bytes(target)
           ct = case File.extname(target).downcase
                when ".css" then "text/css"
                when ".js"  then "application/javascript"
@@ -1851,6 +1930,8 @@ module Tina4
                else "text/plain; charset=utf-8"
                end
           [200, { "content-type" => ct }, [content]]
+        rescue ArgumentError => e
+          json_response({ error: e.message }, 403)
         rescue => e
           json_response({ error: e.message })
         end
@@ -1915,7 +1996,7 @@ module Tina4
           http.read_timeout = 8
           resp = http.request(Net::HTTP::Get.new(uri))
           if resp.is_a?(Net::HTTPSuccess)
-            gems = JSON.parse(resp.body)
+            gems = Tina4.parse_json(resp.body)
             results = gems.first(20).map do |g|
               { name: g["name"], version: g["version"], info: g["info"].to_s[0, 200] }
             end
@@ -2002,20 +2083,21 @@ module Tina4
 
       # Whether the request carried a token matching TINA4_MCP_TOKEN.
       #
-      # Token transports (in order): Authorization: Bearer, X-MCP-Token,
-      # X-Api-Key. Compared timing-safe against TINA4_MCP_TOKEN (fallback
-      # TINA4_API_KEY). With NO configured token this returns false, so a
+      # Token transports (in order): Authorization: Bearer, X-MCP-Token.
+      # MCP transport retains its accepted API_KEY fallback; dedicated dev access does not.
+      # With no configured token this returns false, so a
       # remote caller can never present a "valid" token by accident.
-      def mcp_token_ok?(env)
+      def mcp_token_ok?(env, dedicated: false)
+        # Dedicated non-MCP access never falls back to the application API key.
         expected = ENV["TINA4_MCP_TOKEN"]
-        expected = ENV["TINA4_API_KEY"] if expected.nil? || expected.empty?
+        expected = ENV["TINA4_API_KEY"] if !dedicated && (expected.nil? || expected.empty?)
         return false if expected.nil? || expected.empty?
 
         provided = ""
         auth = (env["HTTP_AUTHORIZATION"] || "").to_s
         provided = auth[7..].to_s.strip if auth.downcase.start_with?("bearer ")
         provided = (env["HTTP_X_MCP_TOKEN"] || "").to_s if provided.empty?
-        provided = (env["HTTP_X_API_KEY"] || "").to_s if provided.empty?
+        provided = (env["HTTP_X_API_KEY"] || "").to_s if !dedicated && provided.empty?
         return false if provided.empty?
 
         secure_equal?(expected.to_s, provided)
@@ -2037,7 +2119,7 @@ module Tina4
       # ── Dev-admin mutation security (feature 127, DEVADMIN-DEC-01/02/03) ──
       # The dashboard writes files, runs SQL and installs gems, so it must
       # assume the developer ALSO browses the web. Two fail-closed gates guard
-      # every /__dev write, and a secret denylist guards the file-read surface.
+      # every /__dev request, and a secret denylist guards the file-read surface.
       # Mirrors tina4_python/dev_admin _dev_same_origin_ok / _dev_mutation_denial
       # / _is_secret_path.
       DEV_SAFE_METHODS = %w[GET HEAD OPTIONS].freeze
@@ -2055,48 +2137,78 @@ module Tina4
       # always sends Sec-Fetch-Site (and any browser sends Origin on a
       # cross-origin POST), so:
       #   - Sec-Fetch-Site present -> trust the browser's own classification
-      #     (cross-site refused; same-origin / same-site / none allowed).
-      #   - else Origin present -> require its host to match the request Host.
+      #     (cross-site and same-site refused; same-origin / none allowed).
+      #   - Origin present -> always require matching scheme, host and port.
       #   - else neither -> not a browser cross-origin request at all (curl, a
       #     test client, a server-side caller); it cannot be a drive-by, so it
       #     is allowed here and the loopback gate still constrains the peer.
       def dev_same_origin_ok?(env)
         sfs = (env["HTTP_SEC_FETCH_SITE"] || "").strip.downcase
-        return %w[same-origin same-site none].include?(sfs) unless sfs.empty?
+        # ADR-0082: same-site is a different origin (a sibling subdomain).
+        return false unless sfs.empty? || %w[same-origin none].include?(sfs)
 
         origin = (env["HTTP_ORIGIN"] || "").strip
         unless origin.empty?
-          netloc = origin.include?("://") ? origin.split("://", 2)[1] : origin
           host = (env["HTTP_HOST"] || "").strip
-          return !host.empty? && netloc.downcase == host.downcase
+          begin
+            given = URI.parse(origin)
+            scheme = Tina4::Request.secure_scheme?(env) ? "https" : "http"
+            expected = URI.parse("#{scheme}://#{host}")
+            return !host.empty? && given.scheme == expected.scheme &&
+              given.host&.downcase == expected.host&.downcase && given.port == expected.port &&
+              given.userinfo.nil? && given.query.nil? && given.fragment.nil? && [nil, "", "/"].include?(given.path)
+          rescue URI::InvalidURIError
+            return false
+          end
         end
         true
       end
 
       # Return a 403 Rack triple to REFUSE a dev-admin write, or nil to allow.
       #
-      # Two independent fail-closed gates on every /__dev mutation:
+      # Independent fail-closed boundaries on every /__dev request:
       #   DEC-01  same-origin (all writes, incl. mcp/call) - drive-by CSRF.
       #   DEC-02  loopback peer (all writes EXCEPT the MCP surface, which carries
       #           its own gate) - a network-exposed debug box.
       # Uses the RAW socket peer (env["REMOTE_ADDR"]), never X-Forwarded-For.
       def dev_mutation_denial(env)
-        method = (env["REQUEST_METHOD"] || "").to_s.upcase
-        return nil if DEV_SAFE_METHODS.include?(method)
         path = (env["PATH_INFO"] || "").to_s
         return nil unless path.start_with?("/__dev")
 
+        # Tokens never bypass the Host and Origin boundaries.
+        return dev_refused("dev-admin: refused (host not allowed)") unless dev_host_allowed?(env)
         return dev_refused("dev-admin: refused (cross-origin request)") unless dev_same_origin_ok?(env)
 
         unless path.start_with?(*DEV_MCP_PREFIXES)
           remote_ip = (env["REMOTE_ADDR"] || "").to_s
-          unless Tina4.is_loopback?(remote_ip) || mcp_token_ok?(env)
+          unless Tina4.is_loopback?(remote_ip) || mcp_token_ok?(env, dedicated: true)
             return dev_refused("dev-admin: refused (non-loopback peer)")
           end
         end
         nil
       end
 
+      # ADR-0082: the Host header must name the loopback machine or the
+      # configured TINA4_HOST, so a rebound DNS name cannot reach /__dev. A
+      # missing Host is not a browser request; the peer gate governs it.
+      def dev_host_allowed?(env)
+        host = (env["HTTP_HOST"] || "").to_s.strip.downcase
+        return true if host.empty?
+
+        name = if host.start_with?("[")
+                 host.include?("]") ? host[1...host.index("]")] : host
+               elsif host.count(":") == 1
+                 host.split(":", 2).first
+               else
+                 host
+               end
+        allowed = %w[localhost 127.0.0.1 ::1]
+        configured = ENV["TINA4_HOST"].to_s.strip.downcase.delete("[]")
+        allowed << configured unless configured.empty?
+        allowed.include?(name)
+      end
+      public :dev_host_allowed?
+
       def dev_refused(message)
         [403, { "content-type" => "application/json; charset=utf-8" },
          [JSON.generate({ "ok" => false, "error" => message })]]
@@ -2105,6 +2217,20 @@ module Tina4
       # DEVADMIN-DEC-03: true when +rel+ names secret material the file endpoints
       # must never serve - .env / .env.* (the .env.example template is allowed),
       # anything under .git/ or secrets/, and private-key material.
+      # A file operation refused for leaving the project answers 403 (parity
+      # with Python); other failures keep their 200 + error body.
+      def file_op_response(payload)
+        json_response(payload, payload[:error].to_s.include?("escapes project") ? 403 : 200)
+      end
+
+      # ADR-0082: the secret denylist judged on the RESOLVED path, so ".env/.",
+      # ".env/x/.." or a symlink to .env cannot slip past the raw-string check.
+      def resolved_secret?(rel)
+        secret_path?(project_relative(safe_project_path(rel)))
+      rescue ArgumentError
+        false
+      end
+
       def secret_path?(rel)
         norm = rel.to_s.tr("\\", "/").gsub(%r{\A/+|/+\z}, "").downcase
         return false if norm.empty?
@@ -2143,7 +2269,7 @@ module Tina4
         })
         raw = server.handle_message(payload)
         return {} if raw.nil? || raw.empty?
-        JSON.parse(raw)
+        Tina4.parse_json(raw)
       end
 
       # Native MCP JSON-RPC endpoint (POST /__dev/mcp[/message]). Real MCP

data/lib/tina4/dev_mailbox.rb

@@ -1,10 +1,15 @@
 # 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 "securerandom"
 require "time"
 require "fileutils"
-require "base64"
 
 module Tina4
   class DevMailbox