nightona 0.191.0

data/lib/nightona/sdk/version.rb

@@ -0,0 +1,10 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  module Sdk
+    VERSION = '0.191.0'
+  end
+end

data/lib/nightona/sdk.rb

@@ -0,0 +1,56 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'logger'
+
+require 'nightona_api_client'
+require 'nightona_toolbox_api_client'
+require 'toml'
+require 'websocket-client-simple'
+
+require_relative 'sdk/version'
+require_relative 'config'
+require_relative 'otel'
+require_relative 'common/charts'
+require_relative 'common/code_interpreter'
+require_relative 'common/code_language'
+require_relative 'common/nightona'
+require_relative 'common/file_system'
+require_relative 'common/image'
+require_relative 'common/git'
+require_relative 'common/process'
+require_relative 'common/pty'
+require_relative 'common/resources'
+require_relative 'common/response'
+require_relative 'common/snapshot'
+require_relative 'code_interpreter'
+require_relative 'computer_use'
+require_relative 'nightona'
+require_relative 'file_system'
+require_relative 'git'
+require_relative 'lsp_server'
+require_relative 'object_storage'
+require_relative 'sandbox'
+require_relative 'snapshot_service'
+require_relative 'util'
+require_relative 'volume'
+require_relative 'volume_service'
+require_relative 'process'
+
+module Nightona
+  module Sdk
+    class Error < StandardError; end
+    class TimeoutError < Error; end
+    class AuthenticationError < Error; end
+    class ForbiddenError < Error; end
+    class NotFoundError < Error; end
+    class ConflictError < Error; end
+    class ValidationError < Error; end
+    class RateLimitError < Error; end
+    class ServerError < Error; end
+
+    def self.logger = @logger ||= Logger.new($stdout, level: Logger::INFO)
+  end
+end

data/lib/nightona/snapshot_service.rb

@@ -0,0 +1,238 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'uri'
+
+module Nightona
+  class SnapshotService
+    include Instrumentation
+
+    SNAPSHOTS_FETCH_LIMIT = 200
+
+    # @param snapshots_api [NightonaApiClient::SnapshotsApi] The snapshots API client
+    # @param object_storage_api [NightonaApiClient::ObjectStorageApi] The object storage API client
+    # @param default_region_id [String, nil] Default region ID for snapshot creation
+    # @param otel_state [Nightona::OtelState, nil]
+    def initialize(snapshots_api:, object_storage_api:, default_region_id: nil, otel_state: nil)
+      @snapshots_api = snapshots_api
+      @object_storage_api = object_storage_api
+      @default_region_id = default_region_id
+      @otel_state = otel_state
+    end
+
+    # List all Snapshots.
+    #
+    # @param page [Integer, Nil]
+    # @param limit [Integer, Nil]
+    # @return [Nightona::PaginatedResource] Paginated list of all Snapshots
+    # @raise [Nightona::Sdk::Error]
+    #
+    # @example
+    #   nightona = Nightona::Nightona.new
+    #   response = nightona.snapshot.list(page: 1, limit: 10)
+    #   snapshots.items.each { |snapshot| puts "#{snapshot.name} (#{snapshot.image_name})" }
+    def list(page: nil, limit: nil)
+      raise Sdk::Error, 'page must be positive integer' if page && page < 1
+
+      raise Sdk::Error, 'limit must be positive integer' if limit && limit < 1
+
+      response = snapshots_api.get_all_snapshots(page:, limit:)
+      PaginatedResource.new(
+        total: response.total,
+        page: response.page,
+        total_pages: response.total_pages,
+        items: response.items.map { |snapshot_dto| Snapshot.from_dto(snapshot_dto) }
+      )
+    end
+
+    # Delete a Snapshot.
+    #
+    # @param snapshot [Nightona::Snapshot] Snapshot to delete
+    # @return [void]
+    #
+    # @example
+    #   nightona = Nightona::Nightona.new
+    #   snapshot = nightona.snapshot.get("demo")
+    #   nightona.snapshot.delete(snapshot)
+    #   puts "Snapshot deleted"
+    def delete(snapshot) = snapshots_api.remove_snapshot(snapshot.id)
+
+    # Get a Snapshot by name.
+    #
+    # @param name [String] Name of the Snapshot to get
+    # @return [Nightona::Snapshot] The Snapshot object
+    #
+    # @example
+    #   nightona = Nightona::Nightona.new
+    #   snapshot = nightona.snapshot.get("demo")
+    #   puts "#{snapshot.name} (#{snapshot.image_name})"
+    def get(name) = Snapshot.from_dto(snapshots_api.get_snapshot(name))
+
+    # Creates and registers a new snapshot from the given Image definition.
+    #
+    # @param params [Nightona::CreateSnapshotParams] Parameters for snapshot creation
+    # @param on_logs [Proc, Nil] Callback proc handling snapshot creation logs
+    # @return [Nightona::Snapshot] The created snapshot
+    #
+    # @example
+    #   image = Image.debianSlim('3.12').pipInstall('numpy')
+    #   params = CreateSnapshotParams.new(name: 'my-snapshot', image: image)
+    #   snapshot = nightona.snapshot.create(params) do |chunk|
+    #     print chunk
+    #   end
+    def create(params, on_logs: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      create_snapshot_req = NightonaApiClient::CreateSnapshot.new(name: params.name)
+
+      if params.image.is_a?(String)
+        create_snapshot_req.image_name = params.image
+        create_snapshot_req.entrypoint = params.entrypoint
+      else
+        create_snapshot_req.build_info = NightonaApiClient::CreateBuildInfo.new(
+          context_hashes: self.class.process_image_context(object_storage_api, params.image),
+          dockerfile_content: if params.entrypoint
+                                params.image.entrypoint(params.entrypoint).dockerfile
+                              else
+                                params.image.dockerfile
+                              end
+        )
+      end
+
+      if params.resources
+        create_snapshot_req.cpu = params.resources.cpu
+        create_snapshot_req.gpu = params.resources.gpu
+        if params.resources.gpu_type
+          create_snapshot_req.gpu_type =
+            params.resources.gpu_type.is_a?(Array) ? params.resources.gpu_type : [params.resources.gpu_type]
+        end
+        create_snapshot_req.memory = params.resources.memory
+        create_snapshot_req.disk = params.resources.disk
+      end
+
+      create_snapshot_req.region_id = params.region_id || @default_region_id
+      create_snapshot_req.sandbox_class = params.sandbox_class
+
+      snapshot = snapshots_api.create_snapshot(create_snapshot_req)
+
+      # Always wait for snapshot to be ready, regardless of on_logs
+      snapshot = wait_for_snapshot(snapshot, on_logs:)
+
+      if [NightonaApiClient::SnapshotState::ERROR, NightonaApiClient::SnapshotState::BUILD_FAILED].include?(snapshot.state)
+        raise Sdk::Error, "Failed to create snapshot #{snapshot.name}, reason: #{snapshot.error_reason}"
+      end
+
+      Snapshot.from_dto(snapshot)
+    end
+
+    # Activate a snapshot
+    #
+    # @param snapshot [Nightona::Snapshot] The snapshot instance
+    # @return [Nightona::Snapshot]
+    def activate(snapshot) = Snapshot.from_dto(snapshots_api.activate_snapshot(snapshot.id))
+
+    instrument :list, :delete, :get, :create, :activate, component: 'SnapshotService'
+
+    # Processes the image context by uploading it to object storage
+    #
+    # @param image [Nightona::Image] The Image instance
+    # @return [Array<String>] List of context hashes stored in object storage
+    def self.process_image_context(object_storage_api, image) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      return [] unless image.context_list && !image.context_list.empty?
+
+      push_access_creds = object_storage_api.get_push_access
+
+      object_storage = ObjectStorage.new(
+        endpoint_url: push_access_creds.storage_url,
+        aws_access_key_id: push_access_creds.access_key,
+        aws_secret_access_key: push_access_creds.secret,
+        aws_session_token: push_access_creds.session_token,
+        bucket_name: push_access_creds.bucket
+      )
+
+      image.context_list.map do |context|
+        object_storage.upload(
+          context.source_path,
+          push_access_creds.organization_id,
+          context.archive_path
+        )
+      end
+    end
+
+    private
+
+    # @return [NightonaApiClient::SnapshotsApi] The snapshots API client
+    attr_reader :snapshots_api
+
+    # @return [NightonaApiClient::ObjectStorageApi, nil] The object storage API client
+    attr_reader :object_storage_api
+
+    # @return [String, nil] Default region ID for snapshot creation
+    attr_reader :default_region_id
+
+    # @return [Nightona::OtelState, nil]
+    attr_reader :otel_state
+
+    # Wait for snapshot to reach a terminal state (ACTIVE, ERROR, or BUILD_FAILED)
+    # Optionally streams logs if on_logs callback is provided
+    #
+    # @param snapshot [NightonaApiClient::SnapshotDto]
+    # @param on_logs [Proc, nil]
+    # @return [NightonaApiClient::SnapshotDto]
+    def wait_for_snapshot(snapshot, on_logs:) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      terminal_states = [
+        NightonaApiClient::SnapshotState::ACTIVE,
+        NightonaApiClient::SnapshotState::ERROR,
+        NightonaApiClient::SnapshotState::BUILD_FAILED
+      ]
+
+      thread = nil
+      previous_state = snapshot.state
+
+      # Log initial state if callback provided
+      on_logs&.call("Creating snapshot #{snapshot.name} (#{snapshot.state})")
+
+      until terminal_states.include?(snapshot.state)
+        Sdk.logger.debug("Waiting for snapshot to be created: #{snapshot.state}")
+
+        # Start log streaming thread if callback provided and snapshot is building
+        if on_logs && thread.nil? && snapshot.state != NightonaApiClient::SnapshotState::PENDING
+          thread = start_log_streaming(snapshot, on_logs:)
+        end
+
+        # Log state changes if callback provided
+        if on_logs && previous_state != snapshot.state
+          if snapshot.state != NightonaApiClient::SnapshotState::PENDING && thread.nil?
+            thread = start_log_streaming(snapshot, on_logs:)
+          end
+          on_logs.call("Creating snapshot #{snapshot.name} (#{snapshot.state})")
+        end
+
+        sleep(1)
+        previous_state = snapshot.state
+        snapshot = snapshots_api.get_snapshot(snapshot.id)
+      end
+
+      thread&.join
+
+      if on_logs && snapshot.state == NightonaApiClient::SnapshotState::ACTIVE
+        on_logs.call("Created snapshot #{snapshot.name} (#{snapshot.state})")
+      end
+
+      snapshot
+    end
+
+    # @param snapshot [NightonaApiClient::SnapshotDto]
+    # @param on_logs [Proc]
+    # @return [Thread]
+    def start_log_streaming(snapshot, on_logs:)
+      # Get build logs URL from API
+      build_logs_response = snapshots_api.get_snapshot_build_logs_url(snapshot.id)
+      uri = URI.parse("#{build_logs_response.url}?follow=true")
+
+      headers = {}
+      snapshots_api.api_client.update_params_for_auth!(headers, nil, ['bearer'])
+      Util.stream_async(uri:, headers:, on_chunk: on_logs)
+    end
+  end
+end

data/lib/nightona/util.rb

@@ -0,0 +1,80 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Nightona
+  module Util
+    STDOUT_PREFIX = "\x01\x01\01"
+    private_constant :STDOUT_PREFIX
+
+    STDERR_PREFIX = "\x02\x02\02"
+    private_constant :STDERR_PREFIX
+
+    PREFIX_LEN = STDOUT_PREFIX.bytesize
+    private_constant :PREFIX_LEN
+
+    def self.demux(line)
+      out_parts = []
+      err_parts = []
+      state = nil
+      pos = 0
+
+      while pos < line.bytesize
+        si = line.index(STDOUT_PREFIX, pos)
+        ei = line.index(STDERR_PREFIX, pos)
+
+        if si && (ei.nil? || si < ei)
+          next_idx = si
+          next_state = :stdout
+        elsif ei
+          next_idx = ei
+          next_state = :stderr
+        else
+          case state
+          when :stdout then out_parts << line[pos..]
+          when :stderr then err_parts << line[pos..]
+          end
+          break
+        end
+
+        if pos < next_idx
+          chunk = line[pos...next_idx]
+          case state
+          when :stdout then out_parts << chunk
+          when :stderr then err_parts << chunk
+          end
+        end
+
+        state = next_state
+        pos = next_idx + PREFIX_LEN
+      end
+
+      [out_parts.join, err_parts.join]
+    end
+
+    # @param uri [URI]
+    # @param on_chunk [Proc]
+    # @param headers [Hash<String, String>]
+    # @return [Thread]
+    def self.stream_async(uri:, on_chunk:, headers: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      Sdk.logger.debug("Starting async stream: #{uri}")
+      Thread.new do
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          request = Net::HTTP::Get.new(uri, headers)
+
+          http.request(request) do |response|
+            response.read_body do |chunk|
+              Sdk.logger.debug("Chunked response received: #{chunk.inspect}")
+              on_chunk.call(chunk)
+            end
+          end
+        end
+      rescue Net::ReadTimeout => e
+        Sdk.logger.debug("Async stream (#{uri}) timeout: #{e.inspect}")
+      end
+    end
+  end
+end

data/lib/nightona/volume.rb

@@ -0,0 +1,46 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  class Volume
+    # @return [String]
+    attr_reader :id
+
+    # @return [String]
+    attr_reader :name
+
+    # @return [String]
+    attr_reader :organization_id
+
+    # @return [String]
+    attr_reader :state
+
+    # @return [String]
+    attr_reader :created_at
+
+    # @return [String]
+    attr_reader :updated_at
+
+    # @return [String]
+    attr_reader :last_used_at
+
+    # @return [String, nil]
+    attr_reader :error_reason
+
+    # Initialize volume from DTO
+    #
+    # @param volume_dto [NightonaApiClient::SandboxVolume]
+    def initialize(volume_dto)
+      @id = volume_dto.id
+      @name = volume_dto.name
+      @organization_id = volume_dto.organization_id
+      @state = volume_dto.state
+      @created_at = volume_dto.created_at
+      @updated_at = volume_dto.updated_at
+      @last_used_at = volume_dto.last_used_at
+      @error_reason = volume_dto.error_reason
+    end
+  end
+end

data/lib/nightona/volume_service.rb

@@ -0,0 +1,61 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  class VolumeService
+    include Instrumentation
+
+    # Service for managing Nightona Volumes. Can be used to list, get, create and delete Volumes.
+    #
+    # @param volumes_api [NightonaApiClient::VolumesApi]
+    # @param otel_state [Nightona::OtelState, nil]
+    def initialize(volumes_api, otel_state: nil)
+      @volumes_api = volumes_api
+      @otel_state = otel_state
+    end
+
+    # Create new Volume.
+    #
+    # @param name [String]
+    # @return [Nightona::Volume]
+    def create(name) = Volume.new(volumes_api.create_volume(NightonaApiClient::CreateVolume.new(name:)))
+
+    # Delete a Volume.
+    #
+    # @param volume [Nightona::Volume]
+    # @return [void]
+    def delete(volume) = volumes_api.delete_volume(volume.id)
+
+    # Get a Volume by name.
+    #
+    # @param name [String]
+    # @param create [Boolean]
+    # @return [Nightona::Volume]
+    def get(name, create: false)
+      Volume.new(volumes_api.get_volume_by_name(name))
+    rescue NightonaApiClient::ApiError => e
+      raise unless create && e.code == 404 && e.message.include?("Volume with name #{name} not found")
+
+      create(name)
+    end
+
+    # List all Volumes.
+    #
+    # @return [Array<Nightona::Volume>]
+    def list
+      volumes_api.list_volumes.map { |volume| Volume.new(volume) }
+    end
+
+    instrument :create, :delete, :get, :list, component: 'VolumeService'
+
+    private
+
+    # @return [NightonaApiClient::VolumesApi]
+    attr_reader :volumes_api
+
+    # @return [Nightona::OtelState, nil]
+    attr_reader :otel_state
+  end
+end

data/lib/nightona.rb

@@ -0,0 +1,10 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+# Main entry point for the Nightona Ruby SDK
+# This file provides a convenient way to require the entire SDK with:
+#   require 'nightona'
+
+require_relative 'nightona/sdk'

data/project.json

@@ -0,0 +1,100 @@
+{
+  "name": "sdk-ruby",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "projectType": "library",
+  "sourceRoot": "libs/sdk-ruby",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "commands": ["rm -f *.gem", "bundle install", "gem build nightona.gemspec"],
+        "parallel": false
+      },
+      "dependsOn": [
+        {
+          "target": "build",
+          "projects": ["api-client-ruby", "toolbox-api-client-ruby"]
+        },
+        "set-version"
+      ],
+      "outputs": ["{projectRoot}/**/*.gem"]
+    },
+    "set-version": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "if [ -n \"$RUBYGEMS_PKG_VERSION\" ]; then sed -i \"s/VERSION = '[^']*'/VERSION = '${RUBYGEMS_PKG_VERSION#v}'/\" lib/nightona/sdk/version.rb && echo \"Changed version to $RUBYGEMS_PKG_VERSION\"; else echo \"Using version from version.rb\"; fi"
+      },
+      "cache": true,
+      "inputs": [
+        { "env": "RUBYGEMS_PKG_VERSION" },
+        { "env": "VERSION" }
+      ],
+      "outputs": ["{projectRoot}/lib/nightona/sdk/version.rb"]
+    },
+    "lint": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "bundle exec rubocop"
+      }
+    },
+    "test": {
+      "executor": "nx:run-commands",
+      "cache": true,
+      "inputs": [
+        "default",
+        "{workspaceRoot}/libs/api-client-ruby/**/*",
+        "{workspaceRoot}/libs/toolbox-api-client-ruby/**/*"
+      ],
+      "outputs": [],
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "bundle exec rspec --format documentation --tag '~e2e'"
+      }
+    },
+    "test:e2e": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "bundle exec rspec spec/e2e_spec.rb --format documentation"
+      }
+    },
+    "format": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "commands": ["bundle exec rubocop -a --fail-level=E"],
+        "parallel": false
+      }
+    },
+    "docs": {
+      "executor": "nx:run-commands",
+      "outputs": ["{workspaceRoot}/apps/docs/src/content/docs/en/ruby-sdk/**/*"],
+      "options": {
+        "cwd": "{projectRoot}",
+        "command": "bash -O extglob -c 'rm -rf ../../apps/docs/src/content/docs/en/ruby-sdk/!(index.mdx)' && bundle exec ruby scripts/generate-docs.rb"
+      }
+    },
+    "publish": {
+      "executor": "nx:run-commands",
+      "options": {
+        "cwd": "{projectRoot}",
+        "commands": [
+          "mkdir -p ~/.gem && echo \":rubygems: $RUBYGEMS_API_KEY\" > ~/.gem/credentials && chmod 0600 ~/.gem/credentials",
+          "gem push nightona-*.gem --key rubygems --host https://rubygems.org"
+        ],
+        "parallel": false
+      },
+      "dependsOn": [
+        {
+          "target": "publish",
+          "projects": ["api-client-ruby", "toolbox-api-client-ruby"]
+        },
+        "build"
+      ]
+    }
+  }
+}