licentivo-launch 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fbb28b47d47a702a68c5a5c787b801d8bac0d2be249ff3e17e0f78202b4f9060
+  data.tar.gz: 100a00bf0c3a53c2b2e0562df7d0b9f66e9d101e7a0b3a44b5566038d9729862
+SHA512:
+  metadata.gz: 805783c773368701c707906a6922be3e3c0d3afd19017c3dd7e5eaa206caea51bcaf81ac78f4463818748219029878d1985958fa31530a8f7d3efeb47bed4c07
+  data.tar.gz: e3230b5ed71e1134333cad7a5bda3e97dd29682fb1867de402ff27ad99727a55cd43ec7723d37d0667e19e7d4b62a51bdf93406bfe010ad34e55d93289541230

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Licentivo Launch contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Launch Ruby 0.1.1
+
+Ruby 3.1+. Install only the Launch gem matching the platform:
+
+```sh
+gem install --local ./licentivo-launch-0.1.1-x64-mingw-ucrt.gem
+```
+
+SDK 0.11.0 Ruby code, its private native core and Windows curl DLL are included. RubyGems resolves the ordinary base64 dependency. The generic source gem builds its own embedded core automatically and needs normal C11/curl/OpenSSL tools for the platform. No official SDK gem or external native-library override is needed.
+
+## Direct initialization and manual lifecycle
+
+LicentivoLaunch::Application.connect(merchant_origin, launch_product_id, licentivo_product_id, trusted_keys, environment: 'live', **options) accepts public parameters directly. Launch provides the filled connect_launch function.
+
+```ruby
+app = connect_launch
+begin
+  app.login(email, password)
+  result = app.run_feature('export') { export_report }
+ensure
+  app.close
+end
+```
+
+restore, logout and release_device must handle errors. CancellationToken is cooperative; cancellation cannot become offline authorization. EncryptedFileStore uses a caller-supplied OS-vault key. It does not store that key beside the ciphertext.
+
+Launch automatically supplies the current merchant URL, existing product mapping and signing public keys when you select the software in its integration page. Copy its connection function, or use the values already shown there when writing code manually. Do not ask the integrator to type two internal product IDs. No launch-config.json or product.json file is required. The merchant URL is mandatory; the official licensing origin is fixed inside the package to https://www.licentivo.com.
+
+The connection function initializes an application; it does not authorize business work. Login obtains only the signed-in customer's credential. Restore checks account expiry, identity, product and environment. Put every protected operation inside the feature guard. Do not substitute merchant order state or a locally saved boolean for the SDK's signed checks.
+
+Normal close stops the runtime. Logout clears local account/cache state and follows this package's remote-session contract. Device release is a separate explicit operation, and failure must be reported. Sessions default to memory. Remembered login needs a protected store; never persist merchant passwords. Scope private SDK cache directories by origin, product, environment and account, and exclude them from installers and logs. Session encryption does not encrypt every official SDK device file.
+
+Only transport failures or HTTP 5xx may attempt an existing cryptographically verified offline grant. Explicit 401/403/404, session/account mismatch, expiration or suspension deny access without offline fallback. Pending retries are finite and honor Retry-After; cancellation and rate limiting never authorize work. First activation and mandatory-online policies retain their network requirements.
+
+Manual development is supported without AI. The combined source bundle includes docs/manual-integration.md with all nine language flows, secure storage, error handling and acceptance procedures. Local package/runtime checks are distinct from external payment and licensing acceptance. Check the current publication status at https://github.com/spf86/licentivo-launch-sdk/blob/main/docs/registry-status.json before using public registry installation commands.

data/ext/launch_native/extconf.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'mkmf'
+require 'shellwords'
+package = File.expand_path('../..', __dir__)
+core = File.join(package, 'vendor/c')
+abort 'Launch bundled SDK core is missing' unless File.file?(File.join(core, 'licentivo.c'))
+$INCFLAGS << " -I#{Shellwords.escape(core)}"
+$VPATH.concat([core, File.join(core, 'vendor')])
+$srcs = %w[licentivo.c cJSON.c monocypher.c monocypher-ed25519.c]
+$CFLAGS << ' -std=c11'
+bundled_curl = File.join(package, 'vendor/curl')
+windows = RbConfig::CONFIG['host_os'].match?(/mswin|mingw/)
+curl = ENV['LICENTIVO_CURL_ROOT'] || (windows && File.directory?(bundled_curl) ? bundled_curl : nil)
+dir_config('curl', File.join(curl, 'include'), File.join(curl, 'lib')) if curl
+pkg_config('libcurl') unless curl
+abort 'A libcurl development package is required by this source build' unless have_header('curl/curl.h') && have_library('curl', 'curl_easy_init')
+if RbConfig::CONFIG['host_os'].match?(/mswin|mingw/)
+  $DLDFLAGS << ' -Wl,--export-all-symbols'
+  have_library('bcrypt'); have_library('advapi32')
+else
+  pkg_config('openssl')
+  abort 'OpenSSL development files are required' unless have_header('openssl/evp.h') && have_library('crypto', 'EVP_sha256')
+  have_library('pthread'); have_library('m')
+end
+if curl && RbConfig::CONFIG['host_os'].match?(/mswin|mingw/)
+  $INSTALLFILES << ['../../vendor/curl/bin/*.dll', '$(RUBYARCHDIR)', '../../vendor/curl/bin']
+end
+create_makefile('licentivo_launch/vendor/licentivo/native/licentivo_native')

data/lib/licentivo_launch/vendor/licentivo.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require 'fiddle'
+require 'json'
+require 'monitor'
+
+module Licentivo
+  VERSION = '0.11.0'
+
+  class Error < StandardError
+    attr_reader :code, :http_status, :request_id, :retryable, :retry_after_seconds
+    def initialize(message, code: 'SDK_ERROR', http_status: 0, request_id: '', retryable: false, retry_after_seconds: 0)
+      @code, @http_status, @request_id = code, http_status, request_id
+      @retryable, @retry_after_seconds = retryable, retry_after_seconds
+      super("#{code}: #{message}#{request_id.empty? ? '' : " (request #{request_id})"}")
+    end
+  end
+
+  Execution = Struct.new(:value, :executed, keyword_init: true) do
+    def replay? = !executed
+  end
+
+  # This library does not register Ruby callbacks on the native heartbeat thread.
+  # Local status reads can be marshalled by the application to its own UI thread.
+  module Native
+    module_function
+    def library
+      @library ||= begin
+        suffix = case RUBY_PLATFORM
+                 when /mswin|mingw/ then 'dll'
+                 when /darwin/ then 'dylib'
+                 else 'so'
+                 end
+        folder = File.expand_path('licentivo/native', __dir__)
+        folders = [folder]
+        spec = Gem.loaded_specs['licentivo-launch'] if defined?(Gem)
+        folders << File.join(spec.extension_dir, 'licentivo_launch/vendor/licentivo/native') if spec
+        path = folders.product([suffix, 'so', 'dll', 'dylib'].uniq).map { |dir, ext| File.join(dir, "licentivo_native.#{ext}") }.find { |file| File.file?(file) }
+        path ||= File.join(folder, "licentivo_native.#{suffix}")
+        unless File.file?(path)
+          raise LoadError, 'Launch private native core is missing. Install the Launch gem for your platform or build its source gem with the normal C11/curl development tools.'
+        end
+        if suffix == 'dll'
+          # Ruby's Windows loader does not search process PATH for dependent
+          # DLLs. Load the matching libcurl explicitly and keep its handle alive.
+          candidates = Dir[File.join(File.dirname(path), 'libcurl*.dll')]
+          if ENV['LICENTIVO_CURL_ROOT']
+            candidates.concat(Dir[File.join(File.expand_path(ENV['LICENTIVO_CURL_ROOT']), 'bin', 'libcurl*.dll')])
+          end
+          @curl_library = Fiddle.dlopen(candidates.first) unless candidates.empty?
+        end
+        Fiddle.dlopen(path)
+      end
+    end
+    def bind(name, arguments, result)
+      # Release the GVL while the core uses the network. Fiddle closures acquire
+      # it again before entering a Ruby block; native heartbeats never enter Ruby.
+      Fiddle::Function.new(library[name], arguments, result, need_gvl: false)
+    end
+    def functions
+      @functions ||= begin
+        p, i, q = Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT, Fiddle::TYPE_LONG_LONG
+        signatures = {
+          init: ['ln_init_file_with_license', [p,p], p],
+          init_json: ['ln_init', [p], p],
+          init_product: ['ln_init_product', [p,p,p], p],
+          start: ['ln_start', [p], i], destroy: ['ln_destroy', [p], Fiddle::TYPE_VOID],
+          last_error: ['ln_last_error', [p], p], error_info: ['ln_get_error_info', [p,p], i],
+          status: ['ln_status', [p], p], feature_status: ['ln_feature_status', [p,p], p],
+          run_feature: ['ln_run_feature', [p,p,p,p], i],
+          run_metered_feature: ['ln_run_metered_feature', [p,p,q,p,p,p], i],
+          resolve_metered_feature: ['ln_resolve_metered_feature', [p,p,i], i],
+          validate: ['ln_validate', [p], i], heartbeat: ['ln_heartbeat', [p], i],
+          refresh_online: ['ln_refresh_online', [p], i], deactivate: ['ln_deactivate', [p], i],
+          reserve: ['ln_reserve', [p,p,q,p], p], consume: ['ln_consume', [p,p,q,p], p],
+          commit: ['ln_commit', [p,p,p], p], cancel: ['ln_cancel', [p,p,p], p],
+          offline_request: ['ln_offline_request', [p,p], p], import_offline: ['ln_import_offline', [p,p,p], i],
+          free_string: ['ln_free_string', [p], Fiddle::TYPE_VOID],
+          json: ['ln_json', [p], p], delete_json: ['cJSON_Delete', [p], Fiddle::TYPE_VOID],
+          verify: ['ln_verify', [p,p,p,p,q], i]
+        }
+        signatures.transform_values { |name, args, result| bind(name, args, result) }
+      end
+    end
+    def call(name, *arguments) = functions.fetch(name).call(*arguments)
+    def input(value)
+      value = String(value)
+      raise ArgumentError, 'Input must not contain NUL bytes' if value.include?("\0")
+      value + "\0"
+    end
+    def text(pointer) = pointer.null? ? '' : pointer.to_s.force_encoding(Encoding::UTF_8)
+    def owned_json(pointer)
+      raise Error.new('Native core returned no result', code: 'INVALID_RESPONSE') if pointer.null?
+      begin
+        JSON.parse(pointer.to_s)
+      ensure
+        call(:free_string, pointer)
+      end
+    end
+  end
+
+  class Client
+    def self.open_config(config, &block)
+      raise ArgumentError, 'Provide an in-code configuration Hash' unless config.is_a?(Hash)
+      open_with_license(config, &block)
+    end
+    def self.open_product(product_id, trusted_keys, customer_key = '')
+      client = new(product_id, customer_key, trusted_keys: trusted_keys)
+      begin
+        client.start
+      rescue Exception
+        client.close
+        raise
+      end
+      return client unless block_given?
+      begin
+        yield client
+      ensure
+        client.close
+      end
+    end
+
+    def self.open_with_license(path, customer_key = '')
+      client = new(path, customer_key)
+      begin
+        client.start
+      rescue Exception
+        client.close
+        raise
+      end
+      return client unless block_given?
+      begin
+        yield client
+      ensure
+        client.close
+      end
+    end
+
+    def initialize(path, customer_key = '', trusted_keys: nil)
+      @lock, @in_callback = Monitor.new, false
+      @native = if path.is_a?(Hash)
+                  Native.call(:init_json, Native.input(JSON.generate(path)))
+                elsif trusted_keys.nil?
+                  Native.call(:init, Native.input(path), Native.input(customer_key))
+                else
+                  Native.call(:init_product, Native.input(path), Native.input(JSON.generate(trusted_keys)), Native.input(customer_key.strip))
+                end
+      if @native.null?
+        @native = nil
+        raise Error.new('Check product ID, public keys and local storage', code: 'CONFIGURATION_ERROR')
+      end
+    end
+
+    def start = checked(:start)
+    def validate = checked(:validate)
+    def heartbeat = checked(:heartbeat)
+    def refresh_online = checked(:refresh_online)
+    def deactivate = checked(:deactivate)
+    def status = read_json(:status)
+    def feature_status(feature) = read_json(:feature_status, Native.input(feature))
+    def reserve(feature, quantity, job_id) = read_json(:reserve, Native.input(feature), integer(quantity), Native.input(job_id))
+    def consume(feature, quantity, job_id) = read_json(:consume, Native.input(feature), integer(quantity), Native.input(job_id))
+    def commit(reservation_id, job_id) = read_json(:commit, Native.input(reservation_id), Native.input(job_id))
+    def cancel(reservation_id, job_id) = read_json(:cancel, Native.input(reservation_id), Native.input(job_id))
+    def offline_request(operation = 'activate') = read_json(:offline_request, Native.input(operation))
+    def import_offline(request, response) = checked(:import_offline, Native.input(JSON.generate(request)), Native.input(JSON.generate(response)))
+    def resolve_metered_feature(job_id, business_succeeded)
+      unless business_succeeded == true || business_succeeded == false
+        raise ArgumentError, 'Determine the real business outcome; pass true or false'
+      end
+      checked(:resolve_metered_feature, Native.input(job_id), business_succeeded ? 1 : 0)
+    end
+
+    def run_feature(feature, &action)
+      execution = run_callback(:run_feature, Native.input(feature), &action)
+      execution.value
+    end
+    def run_metered_feature(feature, quantity, job_id, &action)
+      run_callback(:run_metered_feature, Native.input(feature), integer(quantity), Native.input(job_id), &action)
+    end
+
+    def close
+      @lock.synchronize do
+        raise Error.new('Do not close this client inside its business callback', code: 'WORKFLOW_BUSY') if @in_callback
+        if @native
+          Native.call(:destroy, @native)
+          @native = nil
+        end
+      end
+      nil
+    end
+
+    private
+    def integer(value)
+      raise ArgumentError, 'Quantity must be a positive signed 64-bit integer' unless value.is_a?(Integer) && value.positive? && value <= 0x7fff_ffff_ffff_ffff
+      value
+    end
+    def active
+      raise Error.new('Client is closed', code: 'CLIENT_CLOSED') unless @native
+      @native
+    end
+    def error
+      # ln_error_info: int, char[80], char[128], int, int; the shared ABI uses
+      # 32-bit ints on supported Windows/Linux/macOS targets.
+      info = Fiddle::Pointer.malloc(220, Fiddle::RUBY_FREE)
+      info[0,220] = "\0" * 220
+      Native.call(:error_info, @native, info)
+      Error.new('The licensing operation did not complete',
+        code: info[4,80].split("\0", 2).first,
+        http_status: info[0,4].unpack1('i'), request_id: info[84,128].split("\0", 2).first,
+        retryable: info[212,4].unpack1('i') != 0, retry_after_seconds: info[216,4].unpack1('i'))
+    end
+    def checked(name, *arguments)
+      @lock.synchronize { raise error if Native.call(name, active, *arguments) == 0 }
+      true
+    end
+    def read_json(name, *arguments)
+      @lock.synchronize do
+        pointer = Native.call(name, active, *arguments)
+        raise error if pointer.null?
+        Native.owned_json(pointer)
+      end
+    end
+    def run_callback(name, *arguments)
+      raise ArgumentError, 'Supply your business operation as a block' unless block_given?
+      @lock.synchronize do
+        raise Error.new('A business callback is already running', code: 'WORKFLOW_BUSY') if @in_callback
+        execution = Execution.new(executed: false)
+        business_error = nil
+        callback = Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_INT, [Fiddle::TYPE_VOIDP]) do |_context|
+          @in_callback = true
+          begin
+            execution.executed = true
+            execution.value = yield
+            1
+          rescue Exception => exception
+            # Exceptions never cross the C boundary. The native workflow settles
+            # cancellation (or journals a pending cancellation) before re-raising.
+            business_error = exception
+            0
+          ensure
+            @in_callback = false
+          end
+        end
+        ok = Native.call(name, active, *arguments, callback, 0)
+        raise business_error if business_error
+        raise error if ok == 0
+        execution
+      end
+    end
+  end
+
+  def self.verify_lease(envelope, pins, product, device, now)
+    parsed_envelope = Native.call(:json, Native.input(JSON.generate(envelope)))
+    parsed_pins = Native.call(:json, Native.input(JSON.generate(pins)))
+    begin
+      Native.call(:verify, parsed_envelope, parsed_pins, Native.input(product), Native.input(device), Integer(now)) != 0
+    ensure
+      Native.call(:delete_json, parsed_envelope)
+      Native.call(:delete_json, parsed_pins)
+    end
+  end
+end