toolkami 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1ae1f752dd302a8ae60dad1caff7c12f0c474130d3f46cfec87ab6eaa4a70ed
+  data.tar.gz: 21c8360aeeb363b08ebe5383e0cea9d61706858a9fcc08bf0c6b2587ffbedeae
+SHA512:
+  metadata.gz: 14de59f15537365e4f0e5723333c61adbe330be47353a03b27c9c384543565dfae5ebe16b4686b6124767112d0082b2721fb37c6b8dd0158ff5bc2f70a54c776
+  data.tar.gz: 4e88c77d9c663be3ac70416847ae7d428bde4b1a772fe3e2f937ada8f0ada33883bd280bae4ba7c15eaf54263ac5838ba7915375f5cd01c59c4241119eed4f5b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aperoc
+
+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,34 @@
+# toolkami
+
+Ruby gRPC client for the local `toolkami` daemon.
+
+## Install
+
+```bash
+gem install toolkami
+```
+
+The packaged gem downloads the matching Linux x64 daemon from the GitHub release for the gem version on first client start. Repository checkouts do not download a daemon; they use the local Cargo debug binary instead.
+
+## Usage
+
+```ruby
+require "toolkami"
+
+client = Toolkami::Client.open(tcp_address: "127.0.0.1:50061")
+puts client.get_version.version
+puts client.ping("ruby").message
+client.close
+```
+
+## Development
+
+```bash
+bundle exec rake proto:generate
+bundle exec rake test
+bundle exec rake release:build
+bundle exec rake integration:smoke_local
+```
+
+`release:verify` runs the pre-publish checks with the locally built gem and fails if the version is already on RubyGems.
+`release:verify_published` runs the post-publish smoke test against RubyGems and fails until that version is visible there.

data/lib/toolkami/assert.rb

@@ -0,0 +1,8 @@
+module Toolkami
+  module Assert
+    def self.that(value, message)
+      raise ArgumentError, message unless value
+      true
+    end
+  end
+end

data/lib/toolkami/client.rb

@@ -0,0 +1,109 @@
+require_relative "assert"
+require_relative "daemon"
+require_relative "../toolkami/v1/ping_services_pb"
+
+module Toolkami
+  class Client
+    def self.open(**options)
+      client = new(**options)
+
+      client.start
+      client
+    end
+
+    def initialize(
+      tcp_address: nil,
+      startup_attempts_max: nil,
+      startup_delay_s: nil
+    )
+      @tcp_address = Daemon.resolve_tcp_address(tcp_address)
+      @startup_attempts_max = Daemon.resolve_startup_attempts_max(startup_attempts_max)
+      @startup_delay_s = Daemon.resolve_startup_delay_s(startup_delay_s)
+      @daemon_launch = nil
+      @stub = build_stub(@tcp_address)
+    end
+
+    def close
+      Daemon.terminate(@daemon_launch) unless @daemon_launch.nil?
+      @daemon_launch = nil
+      true
+    end
+
+    def get_version
+      @stub.get_version(Toolkami::V1::GetVersionRequest.new)
+    end
+
+    def ping(name)
+      Assert.that(name.is_a?(String), "name must be a String")
+      Assert.that(!name.empty?, "name must not be empty")
+      @stub.ping(Toolkami::V1::PingRequest.new(name: name))
+    end
+
+    def start
+      return self if ready?
+
+      daemon_bin_path = Daemon.resolve_bin_path
+      @daemon_launch = Daemon.launch(
+        daemon_bin_path: daemon_bin_path,
+        tcp_address: @tcp_address
+      )
+      @stub = build_stub(@tcp_address)
+      wait_for_ready
+      self
+    rescue StandardError => error
+      close
+      raise error
+    end
+
+    private
+
+    def build_stub(tcp_address)
+      stub = Toolkami::V1::ToolkamiService::Stub.new(
+        tcp_address,
+        :this_channel_is_insecure
+      )
+
+      Assert.that(!stub.nil?, "stub must be initialized")
+      Assert.that(tcp_address.include?(":"), "tcp_address must include a port")
+      stub
+    end
+
+    def ready?
+      @stub = build_stub(@tcp_address)
+      get_version
+      true
+    rescue GRPC::BadStatus, Errno::ENOENT
+      false
+    end
+
+    def wait_for_ready
+      attempt_index = 0
+
+      Assert.that(@startup_attempts_max.positive?, "startup_attempts_max must be positive")
+      Assert.that(@startup_delay_s.positive?, "startup_delay_s must be positive")
+      while attempt_index < @startup_attempts_max
+        return true if ready?
+
+        daemon_failure_raise
+        break if attempt_index + 1 >= @startup_attempts_max
+
+        sleep(@startup_delay_s)
+        attempt_index += 1
+      end
+
+      daemon_failure_raise(wait_timeout_s: @startup_delay_s)
+      raise "toolkami daemon did not become ready"
+    end
+
+    def daemon_failure_raise(wait_timeout_s: 0)
+      Assert.that(wait_timeout_s.is_a?(Numeric), "wait_timeout_s must be Numeric")
+      Assert.that(wait_timeout_s >= 0, "wait_timeout_s must be non-negative")
+      return true if @daemon_launch.nil?
+
+      daemon_failure = Daemon.failure(@daemon_launch, wait_timeout_s: wait_timeout_s)
+      return true if daemon_failure.nil?
+
+      raise daemon_failure
+    end
+  end
+end

data/lib/toolkami/daemon.rb

@@ -0,0 +1,131 @@
+require_relative "assert"
+require_relative "install"
+require_relative "release"
+
+module Toolkami
+  module Daemon
+    LaunchResult = Data.define(:daemon_pid, :daemon_stderr_read, :daemon_wait_thread)
+
+    STARTUP_ATTEMPTS_MAX_DEFAULT = 20
+    STARTUP_DELAY_S_DEFAULT = 0.1
+    STDERR_CHUNKS_MAX = 8
+    TCP_ADDRESS_DEFAULT = "127.0.0.1:50061"
+
+    def self.assert_bin_path(daemon_bin_path)
+      Assert.that(daemon_bin_path.is_a?(String), "daemon_bin_path must be a String")
+      Assert.that(!daemon_bin_path.empty?, "daemon_bin_path must not be empty")
+      Assert.that(File.executable?(daemon_bin_path), "daemon binary must be executable")
+      true
+    end
+
+    def self.launch(daemon_bin_path:, tcp_address:)
+      assert_bin_path(daemon_bin_path)
+      daemon_stderr_read, daemon_stderr_write = IO.pipe
+      daemon_pid = Process.spawn(
+        { "TOOLKAMI_TCP_ADDRESS" => tcp_address },
+        daemon_bin_path,
+        out: File::NULL,
+        err: daemon_stderr_write
+      )
+      daemon_stderr_write.close
+
+      Assert.that(daemon_pid.positive?, "daemon pid must be positive")
+      daemon_wait_thread = Process.detach(daemon_pid)
+      LaunchResult.new(daemon_pid, daemon_stderr_read, daemon_wait_thread)
+    rescue StandardError
+      daemon_stderr_read&.close unless daemon_stderr_read.nil? || daemon_stderr_read.closed?
+      daemon_stderr_write&.close unless daemon_stderr_write.nil? || daemon_stderr_write.closed?
+      raise
+    end
+
+    def self.failure(daemon_launch, wait_timeout_s: 0)
+      Assert.that(!daemon_launch.nil?, "daemon_launch must not be nil")
+      Assert.that(wait_timeout_s.is_a?(Numeric), "wait_timeout_s must be Numeric")
+      Assert.that(wait_timeout_s >= 0, "wait_timeout_s must be non-negative")
+      return nil if daemon_launch.daemon_wait_thread.join(wait_timeout_s).nil?
+
+      daemon_status = daemon_launch.daemon_wait_thread.value
+      daemon_stderr = daemon_stderr_read(daemon_launch.daemon_stderr_read)
+      daemon_failure_message(daemon_status, daemon_stderr)
+    end
+
+    def self.terminate(daemon_launch)
+      Assert.that(!daemon_launch.nil?, "daemon_launch must not be nil")
+      unless daemon_launch.daemon_wait_thread.join(0)
+        Process.kill("TERM", daemon_launch.daemon_pid)
+      end
+      true
+    rescue Errno::ESRCH
+      true
+    ensure
+      daemon_launch.daemon_stderr_read.close unless daemon_launch.daemon_stderr_read.closed?
+    end
+
+    def self.resolve_bin_path
+      daemon_bin_path =
+        if Release.repository_checkout_detect
+          Release.daemon_bin_path_checkout_resolve
+        else
+          Install.daemon_bin_path_install
+        end
+
+      assert_bin_path(daemon_bin_path)
+      daemon_bin_path
+    end
+
+    def self.resolve_tcp_address(tcp_address_override)
+      tcp_address = tcp_address_override || ENV["TOOLKAMI_TCP_ADDRESS"] || TCP_ADDRESS_DEFAULT
+
+      Assert.that(!tcp_address.to_s.empty?, "tcp_address must not be empty")
+      Assert.that(tcp_address.include?(":"), "tcp_address must include a port")
+      tcp_address
+    end
+
+    def self.resolve_startup_attempts_max(startup_attempts_max)
+      attempts_max = startup_attempts_max || STARTUP_ATTEMPTS_MAX_DEFAULT
+
+      Assert.that(attempts_max.is_a?(Integer), "startup_attempts_max must be an Integer")
+      Assert.that(attempts_max.positive?, "startup_attempts_max must be positive")
+      attempts_max
+    end
+
+    def self.resolve_startup_delay_s(startup_delay_s)
+      delay_s = startup_delay_s || STARTUP_DELAY_S_DEFAULT
+
+      Assert.that(delay_s.is_a?(Numeric), "startup_delay_s must be Numeric")
+      Assert.that(delay_s.positive?, "startup_delay_s must be positive")
+      delay_s
+    end
+
+    def self.daemon_failure_message(daemon_status, daemon_stderr)
+      Assert.that(!daemon_status.nil?, "daemon_status must not be nil")
+      daemon_status_text =
+        if daemon_status.exitstatus.nil?
+          "signal #{daemon_status.termsig || 'unknown'}"
+        else
+          "code #{daemon_status.exitstatus}"
+        end
+      daemon_stderr_text = daemon_stderr.strip
+      daemon_message = "toolkami daemon exited before becoming ready (#{daemon_status_text})"
+
+      return daemon_message if daemon_stderr_text.empty?
+
+      "#{daemon_message} stderr: #{daemon_stderr_text}"
+    end
+
+    def self.daemon_stderr_read(daemon_stderr_read)
+      Assert.that(!daemon_stderr_read.nil?, "daemon_stderr_read must not be nil")
+      daemon_chunks = []
+      daemon_index = 0
+
+      until daemon_stderr_read.eof? || daemon_index >= STDERR_CHUNKS_MAX
+        daemon_chunks << daemon_stderr_read.readpartial(256)
+        daemon_index += 1
+      end
+
+      daemon_chunks.join
+    rescue EOFError
+      daemon_chunks.join
+    end
+  end
+end

data/lib/toolkami/generated.rb

@@ -0,0 +1,19 @@
+module Toolkami
+  module Generated
+    GENERATED_FILES = [
+      File.expand_path("v1/ping_pb.rb", __dir__),
+      File.expand_path("v1/ping_services_pb.rb", __dir__),
+    ].freeze
+
+    def self.assert_ready
+      missing_paths = GENERATED_FILES.reject { |generated_path| File.file?(generated_path) }
+
+      return true if missing_paths.empty?
+
+      raise LoadError,
+        "generated Ruby gRPC files are missing; run `bundle exec rake proto:generate` in sdk/toolkami/ruby"
+    end
+  end
+end
+
+Toolkami::Generated.assert_ready

data/lib/toolkami/install.rb

@@ -0,0 +1,126 @@
+require "fileutils"
+require "net/http"
+require "rbconfig"
+require "uri"
+
+require_relative "assert"
+require_relative "release"
+
+module Toolkami
+  module Install
+    DOWNLOAD_OPEN_TIMEOUT_S = 15
+    DOWNLOAD_READ_TIMEOUT_S = 15
+    DOWNLOAD_REDIRECTS_MAX = 5
+    DOWNLOAD_SIZE_BYTES_MAX = 50 * 1024 * 1024
+
+    def self.daemon_bin_path_install
+      platform_assert
+      daemon_bin_path = Release.daemon_bin_path_packaged_resolve
+      return daemon_bin_path if daemon_bin_path_ready?(daemon_bin_path)
+
+      daemon_bytes = daemon_bytes_download
+      daemon_bin_file_write(daemon_bin_path, daemon_bytes)
+      daemon_bin_path_assert(daemon_bin_path)
+      daemon_bin_path
+    end
+
+    def self.platform_assert
+      host_cpu = RbConfig::CONFIG["host_cpu"]
+      host_os = RbConfig::CONFIG["host_os"]
+
+      Assert.that(host_cpu.is_a?(String), "host_cpu must be a String")
+      Assert.that(host_os.is_a?(String), "host_os must be a String")
+      return true if host_os.include?("linux") && ["x86_64", "amd64"].include?(host_cpu)
+
+      raise "toolkami supports only linux x64 for automatic daemon installation"
+    end
+
+    def self.daemon_bytes_download
+      package_version = Release.package_version_resolve
+      release_artifact_url = Release.release_artifact_url_resolve(package_version)
+      response = http_response_fetch(URI(release_artifact_url))
+      daemon_bytes = response.body
+
+      Assert.that(daemon_bytes.is_a?(String), "daemon_bytes must be a String")
+      Assert.that(!daemon_bytes.empty?, "daemon_bytes must not be empty")
+      Assert.that(daemon_bytes.bytesize <= DOWNLOAD_SIZE_BYTES_MAX, "daemon_bytes must be bounded")
+      daemon_bytes
+    end
+
+    def self.http_response_fetch(release_artifact_uri)
+      redirect_index = 0
+      current_uri = release_artifact_uri
+
+      Assert.that(current_uri.is_a?(URI::HTTPS), "release_artifact_uri must be HTTPS")
+      while redirect_index <= DOWNLOAD_REDIRECTS_MAX
+        response = http_response_request(current_uri)
+        return response if response.is_a?(Net::HTTPSuccess)
+
+        current_uri = http_response_redirect_uri(current_uri, response)
+        redirect_index += 1
+      end
+
+      raise "toolkami daemon download exceeded redirect limit"
+    end
+
+    def self.http_response_request(release_artifact_uri)
+      response = nil
+
+      Assert.that(release_artifact_uri.is_a?(URI::HTTP), "release_artifact_uri must be HTTP or HTTPS")
+      Assert.that(!release_artifact_uri.host.to_s.empty?, "release_artifact_uri host must not be empty")
+      Net::HTTP.start(
+        release_artifact_uri.host,
+        release_artifact_uri.port,
+        use_ssl: release_artifact_uri.scheme == "https",
+        open_timeout: DOWNLOAD_OPEN_TIMEOUT_S,
+        read_timeout: DOWNLOAD_READ_TIMEOUT_S
+      ) do |http_client|
+        request = Net::HTTP::Get.new(release_artifact_uri)
+        response = http_client.request(request)
+      end
+
+      Assert.that(!response.nil?, "response must be present")
+      Assert.that(response.code.to_i.positive?, "response code must be positive")
+      return response if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+
+      raise "toolkami daemon download failed: #{response.code} #{response.message}"
+    end
+
+    def self.http_response_redirect_uri(release_artifact_uri, response)
+      location_header = response["location"]
+
+      Assert.that(response.is_a?(Net::HTTPRedirection), "response must be a redirect")
+      Assert.that(location_header.is_a?(String), "redirect location must be a String")
+      redirect_uri = URI.join(release_artifact_uri.to_s, location_header)
+      Assert.that(redirect_uri.is_a?(URI::HTTP), "redirect_uri must be HTTP or HTTPS")
+      redirect_uri
+    end
+
+    def self.daemon_bin_file_write(daemon_bin_path, daemon_bytes)
+      daemon_directory_path = File.dirname(daemon_bin_path)
+      daemon_temp_path = "#{daemon_bin_path}.tmp"
+
+      Assert.that(daemon_bin_path.end_with?("/toolkami"), "daemon_bin_path must end with /toolkami")
+      Assert.that(daemon_bytes.bytesize.positive?, "daemon_bytes must not be empty")
+      FileUtils.mkdir_p(daemon_directory_path)
+      File.binwrite(daemon_temp_path, daemon_bytes)
+      File.chmod(0o755, daemon_temp_path)
+      File.rename(daemon_temp_path, daemon_bin_path)
+      daemon_bin_path
+    ensure
+      FileUtils.rm_f(daemon_temp_path) unless daemon_temp_path.nil?
+    end
+
+    def self.daemon_bin_path_ready?(daemon_bin_path)
+      Assert.that(daemon_bin_path.is_a?(String), "daemon_bin_path must be a String")
+      Assert.that(!daemon_bin_path.empty?, "daemon_bin_path must not be empty")
+      File.file?(daemon_bin_path) && File.executable?(daemon_bin_path)
+    end
+
+    def self.daemon_bin_path_assert(daemon_bin_path)
+      Assert.that(File.file?(daemon_bin_path), "daemon binary must exist")
+      Assert.that(File.executable?(daemon_bin_path), "daemon binary must be executable")
+      true
+    end
+  end
+end

data/lib/toolkami/release.rb

@@ -0,0 +1,63 @@
+require "uri"
+
+require_relative "assert"
+require_relative "version"
+
+module Toolkami
+  module Release
+    RELEASE_ASSET_NAME = "toolkami-linux-x64"
+    RELEASE_BASE_URL = "https://github.com/aperoc/toolkami/releases"
+
+    def self.daemon_bin_path_checkout_resolve
+      daemon_bin_path = File.expand_path("../../../../../src/toolkami/target/debug/toolkami", __dir__)
+
+      Assert.that(daemon_bin_path.end_with?("/toolkami"), "checkout daemon path must end with /toolkami")
+      Assert.that(daemon_bin_path.include?("/src/toolkami/target/debug/"), "checkout daemon path must target cargo debug output")
+      daemon_bin_path
+    end
+
+    def self.daemon_bin_path_packaged_resolve
+      daemon_bin_path = File.expand_path("../../bin/toolkami", __dir__)
+
+      Assert.that(daemon_bin_path.end_with?("/bin/toolkami"), "packaged daemon path must end with /bin/toolkami")
+      Assert.that(daemon_bin_path.include?("/sdk/toolkami/ruby/") || daemon_bin_path.include?("/gems/toolkami-"), "packaged daemon path must target sdk or gem install")
+      daemon_bin_path
+    end
+
+    def self.package_root_path_resolve
+      package_root_path = File.expand_path("../..", __dir__)
+
+      Assert.that(File.absolute_path(package_root_path) == package_root_path, "package_root_path must be absolute")
+      Assert.that(package_root_path.include?("toolkami"), "package_root_path must include toolkami")
+      package_root_path
+    end
+
+    def self.package_version_resolve
+      package_version = Toolkami::VERSION
+
+      Assert.that(package_version.is_a?(String), "package_version must be a String")
+      Assert.that(!package_version.empty?, "package_version must not be empty")
+      Assert.that(!package_version.include?(" "), "package_version must not contain spaces")
+      package_version
+    end
+
+    def self.release_artifact_url_resolve(package_version)
+      release_artifact_url = URI.join(
+        "#{RELEASE_BASE_URL}/",
+        "download/v#{package_version}/#{RELEASE_ASSET_NAME}"
+      ).to_s
+
+      Assert.that(package_version.is_a?(String), "package_version must be a String")
+      Assert.that(release_artifact_url.include?("/v#{package_version}/"), "release_artifact_url must include version")
+      release_artifact_url
+    end
+
+    def self.repository_checkout_detect
+      cargo_toml_path = File.expand_path("../../../../../src/toolkami/Cargo.toml", __dir__)
+
+      Assert.that(cargo_toml_path.end_with?("/Cargo.toml"), "cargo_toml_path must end with /Cargo.toml")
+      Assert.that(cargo_toml_path.include?("/src/toolkami/"), "cargo_toml_path must point to the toolkami crate")
+      File.readable?(cargo_toml_path)
+    end
+  end
+end

data/lib/toolkami/v1/ping_pb.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: toolkami/v1/ping.proto
+
+require 'google/protobuf'
+
+
+descriptor_data = "\n\x16toolkami/v1/ping.proto\x12\x0btoolkami.v1\"\x13\n\x11GetVersionRequest\":\n\x12GetVersionResponse\x12\x0f\n\x07version\x18\x01 \x01(\t\x12\x13\n\x0btcp_address\x18\x02 \x01(\t\"\x1b\n\x0bPingRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"\x1f\n\x0cPingResponse\x12\x0f\n\x07message\x18\x01 \x01(\t2\x9d\x01\n\x0fToolkamiService\x12M\n\nGetVersion\x12\x1e.toolkami.v1.GetVersionRequest\x1a\x1f.toolkami.v1.GetVersionResponse\x12;\n\x04Ping\x12\x18.toolkami.v1.PingRequest\x1a\x19.toolkami.v1.PingResponseb\x06proto3"
+
+pool = ::Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Toolkami
+  module V1
+    GetVersionRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("toolkami.v1.GetVersionRequest").msgclass
+    GetVersionResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("toolkami.v1.GetVersionResponse").msgclass
+    PingRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("toolkami.v1.PingRequest").msgclass
+    PingResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("toolkami.v1.PingResponse").msgclass
+  end
+end

data/lib/toolkami/v1/ping_services_pb.rb

@@ -0,0 +1,25 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# Source: toolkami/v1/ping.proto for package 'toolkami.v1'
+
+require 'grpc'
+require 'toolkami/v1/ping_pb'
+
+module Toolkami
+  module V1
+    module ToolkamiService
+      class Service
+
+        include ::GRPC::GenericService
+
+        self.marshal_class_method = :encode
+        self.unmarshal_class_method = :decode
+        self.service_name = 'toolkami.v1.ToolkamiService'
+
+        rpc :GetVersion, ::Toolkami::V1::GetVersionRequest, ::Toolkami::V1::GetVersionResponse
+        rpc :Ping, ::Toolkami::V1::PingRequest, ::Toolkami::V1::PingResponse
+      end
+
+      Stub = Service.rpc_stub_class
+    end
+  end
+end

data/lib/toolkami/version.rb

@@ -0,0 +1,3 @@
+module Toolkami
+  VERSION = "0.1.2"
+end

data/lib/toolkami.rb

@@ -0,0 +1,9 @@
+require_relative "toolkami/version"
+require_relative "toolkami/assert"
+require_relative "toolkami/generated"
+require_relative "toolkami/release"
+require_relative "toolkami/install"
+require_relative "toolkami/client"
+
+module Toolkami
+end

data/toolkami.gemspec

@@ -0,0 +1,29 @@
+lib_path = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+require "toolkami/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "toolkami"
+  spec.version = Toolkami::VERSION
+  spec.authors = ["Aperoc"]
+  spec.email = ["aperoc@users.noreply.github.com"]
+  spec.summary = "Toolkami Ruby SDK for the local Rust daemon"
+  spec.description = "Ruby gRPC SDK for the local Toolkami daemon with automatic packaged daemon installation."
+  spec.homepage = "https://github.com/aperoc/toolkami"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.3.0"
+  spec.metadata["source_code_uri"] = "https://github.com/aperoc/toolkami"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/aperoc/toolkami/issues"
+  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.files = Dir.chdir(__dir__) do
+    Dir[
+      "LICENSE",
+      "README.md",
+      "lib/**/*.rb",
+      "toolkami.gemspec"
+    ]
+  end
+  spec.require_paths = ["lib"]
+  spec.add_dependency "google-protobuf", "4.34.0"
+  spec.add_dependency "grpc", "1.78.1"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: toolkami
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Aperoc
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.34.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.34.0
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.78.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.78.1
+description: Ruby gRPC SDK for the local Toolkami daemon with automatic packaged daemon
+  installation.
+email:
+- aperoc@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/toolkami.rb
+- lib/toolkami/assert.rb
+- lib/toolkami/client.rb
+- lib/toolkami/daemon.rb
+- lib/toolkami/generated.rb
+- lib/toolkami/install.rb
+- lib/toolkami/release.rb
+- lib/toolkami/v1/ping_pb.rb
+- lib/toolkami/v1/ping_services_pb.rb
+- lib/toolkami/version.rb
+- toolkami.gemspec
+homepage: https://github.com/aperoc/toolkami
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/aperoc/toolkami
+  bug_tracker_uri: https://github.com/aperoc/toolkami/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Toolkami Ruby SDK for the local Rust daemon
+test_files: []