nightona 0.191.0

data/lib/nightona/common/nightona.rb

@@ -0,0 +1,230 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  CODE_TOOLBOX_LANGUAGE_LABEL = 'code-toolbox-language'
+
+  class CreateSandboxBaseParams
+    # @return [Symbol, nil] Programming language for the Sandbox
+    attr_accessor :language
+
+    # @return [String, nil] OS user for the Sandbox
+    attr_accessor :os_user
+
+    # @return [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    attr_accessor :env_vars
+
+    # @return [Hash<String, String>, nil] Custom labels for the Sandbox
+    attr_accessor :labels
+
+    # @return [Boolean, nil] Whether the Sandbox should be public
+    attr_accessor :public
+
+    # @return [Float, nil] Timeout in seconds for Sandbox to be created and started
+    attr_accessor :timeout
+
+    # @return [Integer, nil] Auto-stop interval in minutes
+    attr_accessor :auto_stop_interval
+
+    # @return [Integer, nil] Auto-archive interval in minutes
+    attr_accessor :auto_archive_interval
+
+    # @return [Integer, nil] Auto-delete interval in minutes
+    attr_accessor :auto_delete_interval
+
+    # @return [Array<NightonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    attr_accessor :volumes
+
+    # @return [Boolean, nil] Whether to block all network access for the Sandbox
+    attr_accessor :network_block_all
+
+    # @return [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    attr_accessor :network_allow_list
+
+    # @return [String, nil] Comma-separated list of allowed domains for the Sandbox
+    attr_accessor :domain_allow_list
+
+    # @return [Boolean, nil] Whether the Sandbox should be ephemeral
+    attr_accessor :ephemeral
+
+    # @return [String, nil] ID or name of an existing Sandbox to link the new Sandbox to. The new
+    #   Sandbox will be scheduled on the same runner as the linked Sandbox so a local network can be
+    #   established between them. Linked Sandboxes must be
+    #   ephemeral (auto_delete_interval=0) and cannot themselves be linked to another Sandbox.
+    attr_accessor :linked_sandbox
+
+    # Initialize CreateSandboxBaseParams
+    #
+    # @param language [Symbol, nil] Programming language for the Sandbox
+    # @param os_user [String, nil] OS user for the Sandbox
+    # @param env_vars [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    # @param labels [Hash<String, String>, nil] Custom labels for the Sandbox
+    # @param public [Boolean, nil] Whether the Sandbox should be public
+    # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
+    # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
+    # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
+    # @param volumes [Array<NightonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
+    # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    # @param domain_allow_list [String, nil] Comma-separated list of allowed domains for the Sandbox
+    # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    # @param linked_sandbox [String, nil] ID or name of an existing Sandbox to link the new Sandbox to
+    def initialize( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      language: nil,
+      os_user: nil,
+      env_vars: nil,
+      labels: nil,
+      public: nil,
+      timeout: nil,
+      auto_stop_interval: nil,
+      auto_archive_interval: nil,
+      auto_delete_interval: nil,
+      volumes: nil,
+      network_block_all: nil,
+      network_allow_list: nil,
+      domain_allow_list: nil,
+      ephemeral: nil,
+      linked_sandbox: nil
+    )
+      @language = language
+      @os_user = os_user
+      @env_vars = env_vars
+      @labels = labels
+      @public = public
+      @timeout = timeout
+      @auto_stop_interval = auto_stop_interval
+      @auto_archive_interval = auto_archive_interval
+      @auto_delete_interval = auto_delete_interval
+      @volumes = volumes
+      @network_block_all = network_block_all
+      @network_allow_list = network_allow_list
+      @domain_allow_list = domain_allow_list
+      @ephemeral = ephemeral
+      @linked_sandbox = linked_sandbox
+
+      # Handle ephemeral and auto_delete_interval conflict
+      handle_ephemeral_auto_delete_conflict
+    end
+
+    # Convert to hash representation
+    #
+    # @return [Hash<Symbol, Object>] Hash representation of the parameters
+    def to_h # rubocop:disable Metrics/MethodLength
+      {
+        language:,
+        os_user:,
+        env_vars:,
+        labels:,
+        public:,
+        timeout:,
+        auto_stop_interval:,
+        auto_archive_interval:,
+        auto_delete_interval:,
+        volumes:,
+        network_block_all:,
+        network_allow_list:,
+        domain_allow_list:,
+        ephemeral:,
+        linked_sandbox:
+      }.compact
+    end
+
+    private
+
+    # Handle the conflict between ephemeral and auto_delete_interval
+    #
+    # @return [void]
+    def handle_ephemeral_auto_delete_conflict
+      return unless ephemeral && auto_delete_interval && !auto_delete_interval.zero?
+
+      warn(
+        "'ephemeral' and 'auto_delete_interval' cannot be used together. " \
+        'If ephemeral is true, auto_delete_interval will be ignored and set to 0.'
+      )
+      @auto_delete_interval = 0
+    end
+  end
+
+  class CreateSandboxFromImageParams < CreateSandboxBaseParams
+    # @return [String, Image] Custom Docker image to use for the Sandbox. If an Image object is provided,
+    #   the image will be dynamically built.
+    attr_accessor :image
+
+    # @return [Nightona::Resources, nil] Resource configuration for the Sandbox. If not provided, sandbox will
+    #   have default resources.
+    attr_accessor :resources
+
+    # Initialize CreateSandboxFromImageParams
+    #
+    # @param image [String, Image] Custom Docker image to use for the Sandbox
+    # @param resources [Nightona::Resources, nil] Resource configuration for the Sandbox
+    # @param language [Symbol, nil] Programming language for the Sandbox
+    # @param os_user [String, nil] OS user for the Sandbox
+    # @param env_vars [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    # @param labels [Hash<String, String>, nil] Custom labels for the Sandbox
+    # @param public [Boolean, nil] Whether the Sandbox should be public
+    # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
+    # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
+    # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
+    # @param volumes [Array<NightonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
+    # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    # @param domain_allow_list [String, nil] Comma-separated list of allowed domains for the Sandbox
+    # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    def initialize(image:, resources: nil, **args)
+      @image = image
+      @resources = resources
+
+      super(**args)
+    end
+
+    # Convert to hash representation
+    #
+    # @return [Hash<Symbol, Object>] Hash representation of the parameters
+    def to_h
+      super.merge(
+        image:,
+        resources: resources&.to_h
+      ).compact
+    end
+  end
+
+  class CreateSandboxFromSnapshotParams < CreateSandboxBaseParams
+    # @return [String, nil] Name of the snapshot to use for the Sandbox
+    attr_accessor :snapshot
+
+    # Initialize CreateSandboxFromSnapshotParams
+    #
+    # @param snapshot [String, nil] Name of the snapshot to use for the Sandbox
+    # @param language [Symbol, nil] Programming language for the Sandbox
+    # @param os_user [String, nil] OS user for the Sandbox
+    # @param env_vars [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    # @param labels [Hash<String, String>, nil] Custom labels for the Sandbox
+    # @param public [Boolean, nil] Whether the Sandbox should be public
+    # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
+    # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
+    # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
+    # @param volumes [Array<NightonaApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
+    # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    # @param domain_allow_list [String, nil] Comma-separated list of allowed domains for the Sandbox
+    # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    def initialize(snapshot: nil, **args)
+      @snapshot = snapshot
+
+      super(**args)
+    end
+
+    # Convert to hash representation
+    #
+    # @return [Hash<Symbol, Object>] Hash representation of the parameters
+    def to_h
+      super.merge(snapshot:).compact
+    end
+  end
+end

data/lib/nightona/common/process.rb

@@ -0,0 +1,149 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  class ExecuteResponse
+    # @return [Integer] The exit code from the command execution
+    attr_reader :exit_code
+
+    # @return [String] The output from the command execution
+    attr_reader :result
+
+    # @return [ExecutionArtifacts, nil] Artifacts from the command execution
+    attr_reader :artifacts
+
+    # @return [Hash] Additional properties from the response
+    attr_reader :additional_properties
+
+    # Initialize a new ExecuteResponse
+    #
+    # @param exit_code [Integer] The exit code from the command execution
+    # @param result [String] The output from the command execution
+    # @param artifacts [ExecutionArtifacts, nil] Artifacts from the command execution
+    # @param additional_properties [Hash] Additional properties from the response
+    def initialize(exit_code:, result:, artifacts: nil, additional_properties: {})
+      @exit_code = exit_code
+      @result = result
+      @artifacts = artifacts
+      @additional_properties = additional_properties
+    end
+  end
+
+  class ExecutionArtifacts
+    # @return [String] Standard output from the command, same as `result` in `ExecuteResponse`
+    attr_accessor :stdout
+
+    # @return [Array] List of chart metadata from matplotlib
+    attr_accessor :charts
+
+    # Initialize a new ExecutionArtifacts
+    #
+    # @param stdout [String] Standard output from the command
+    # @param charts [Array] List of chart metadata from matplotlib
+    def initialize(stdout = '', charts = [])
+      @stdout = stdout
+      @charts = charts
+    end
+  end
+
+  class CodeRunParams
+    # @return [Array<String>, nil] Command line arguments
+    attr_accessor :argv
+
+    # @return [Hash<String, String>, nil] Environment variables
+    attr_accessor :env
+
+    # Initialize a new CodeRunParams
+    #
+    # @param argv [Array<String>, nil] Command line arguments
+    # @param env [Hash<String, String>, nil] Environment variables
+    def initialize(argv: nil, env: nil)
+      @argv = argv
+      @env = env
+    end
+  end
+
+  class SessionExecuteRequest
+    # @return [String] The command to execute
+    attr_accessor :command
+
+    # @return [Boolean] Whether to execute the command asynchronously
+    attr_accessor :run_async
+
+    # @return [Boolean] Whether to suppress input echo
+    attr_accessor :suppress_input_echo
+
+    # Initialize a new SessionExecuteRequest
+    #
+    # @param command [String] The command to execute
+    # @param run_async [Boolean] Whether to execute the command asynchronously
+    # @param suppress_input_echo [Boolean] Whether to suppress input echo (default is false)
+    def initialize(command:, run_async: false, suppress_input_echo: false)
+      @command = command
+      @run_async = run_async
+      @suppress_input_echo = suppress_input_echo
+    end
+  end
+
+  class SessionExecuteResponse
+    # @return [String, nil] Unique identifier for the executed command
+    attr_reader :cmd_id
+
+    # @return [String, nil] The output from the command execution
+    attr_reader :output
+
+    # @return [String, nil] Standard output from the command
+    attr_reader :stdout
+
+    # @return [String, nil] Standard error from the command
+    attr_reader :stderr
+
+    # @return [Integer, nil] The exit code from the command execution
+    attr_reader :exit_code
+
+    # @return [Hash] Additional properties from the response
+    attr_reader :additional_properties
+
+    # Initialize a new SessionExecuteResponse
+    #
+    # @param opts [Hash] Options for the SessionExecuteResponse
+    # @param cmd_id [String, nil] Unique identifier for the executed command
+    # @param output [String, nil] The output from the command execution
+    # @param stdout [String, nil] Standard output from the command
+    # @param stderr [String, nil] Standard error from the command
+    # @param exit_code [Integer, nil] The exit code from the command execution
+    # @param additional_properties [Hash] Additional properties from the response
+    def initialize(opts = {})
+      @cmd_id = opts.fetch(:cmd_id, nil)
+      @output = opts.fetch(:output, nil)
+      @stdout = opts.fetch(:stdout, nil)
+      @stderr = opts.fetch(:stderr, nil)
+      @exit_code = opts.fetch(:exit_code, nil)
+      @additional_properties = opts.fetch(:additional_properties, {})
+    end
+  end
+
+  class SessionCommandLogsResponse
+    # @return [String, nil] The combined output from the command
+    attr_reader :output
+
+    # @return [String, nil] The stdout from the command
+    attr_reader :stdout
+
+    # @return [String, nil] The stderr from the command
+    attr_reader :stderr
+
+    # Initialize a new SessionCommandLogsResponse
+    #
+    # @param output [String, nil] The combined output from the command
+    # @param stdout [String, nil] The stdout from the command
+    # @param stderr [String, nil] The stderr from the command
+    def initialize(output: nil, stdout: nil, stderr: nil)
+      @output = output
+      @stdout = stdout
+      @stderr = stderr
+    end
+  end
+end

data/lib/nightona/common/pty.rb

@@ -0,0 +1,309 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'json'
+require 'observer'
+
+module Nightona
+  class PtySize
+    # @return [Integer] Number of terminal rows (height)
+    attr_reader :rows
+
+    # @return [Integer] Number of terminal columns (width)
+    attr_reader :cols
+
+    # Initialize a new PtySize
+    #
+    # @param rows [Integer] Number of terminal rows (height)
+    # @param cols [Integer] Number of terminal columns (width)
+    def initialize(rows:, cols:)
+      @rows = rows
+      @cols = cols
+    end
+  end
+
+  class PtyResult
+    # @return [Integer, nil] Exit code of the PTY process (0 for success, non-zero for errors).
+    #                        nil if the process hasn't exited yet or exit code couldn't be determined.
+    attr_reader :exit_code
+
+    # @return [String, nil] Error message if the PTY failed or was terminated abnormally.
+    #                       nil if no error occurred.
+    attr_reader :error
+
+    # Initialize a new PtyResult
+    #
+    # @param exit_code [Integer, nil] Exit code of the PTY process
+    # @param error [String, nil] Error message if the PTY failed
+    def initialize(exit_code: nil, error: nil)
+      @exit_code = exit_code
+      @error = error
+    end
+  end
+
+  class PtyHandle # rubocop:disable Metrics/ClassLength
+    include Observable
+
+    # @return [String] Session ID of the PTY session
+    attr_reader :session_id
+
+    # @return [Integer, nil] Exit code of the PTY process (if terminated)
+    attr_reader :exit_code
+
+    # @return [String, nil] Error message if the PTY failed
+    attr_reader :error
+
+    # Initialize the PTY handle.
+    #
+    # @param websocket [WebSocket::Client::Simple::Client] Connected WebSocket client connection
+    # @param session_id [String] Session ID of the PTY session
+    # @param handle_resize [Proc, nil] Optional callback for resizing the PTY
+    # @param handle_kill [Proc, nil] Optional callback for killing the PTY
+    def initialize(websocket, session_id:, handle_resize: nil, handle_kill: nil)
+      @websocket = websocket
+      @session_id = session_id
+      @handle_resize = handle_resize
+      @handle_kill = handle_kill
+      @exit_code = nil
+      @error = nil
+      @logger = Sdk.logger
+
+      @status = Status::INIT
+      subscribe
+    end
+
+    # Check if connected to the PTY session
+    #
+    # @return [Boolean] true if connected, false otherwise
+    def connected? = websocket.open?
+
+    # Wait for the PTY connection to be established
+    #
+    # @param timeout [Float] Maximum time in seconds to wait for connection. Defaults to 10.0
+    # @return [void]
+    # @raise [Nightona::Sdk::Error] If connection timeout is exceeded
+    def wait_for_connection(timeout: DEFAULT_TIMEOUT)
+      return if status == Status::CONNECTED
+
+      start_time = Time.now
+
+      sleep(SLEEP_INTERVAL) until status == Status::CONNECTED || (Time.now - start_time) > timeout
+
+      raise Sdk::Error, 'PTY connection timeout' unless status == Status::CONNECTED
+    end
+
+    # Send input to the PTY session
+    #
+    # @param input [String] Input to send to the PTY
+    # @return [void]
+    def send_input(input)
+      raise Sdk::Error, 'PTY session not connected' unless websocket.open?
+
+      websocket.send(input)
+    end
+
+    # Resize the PTY terminal
+    #
+    # @param pty_size [PtySize] New terminal size
+    # @return [NightonaApiClient::PtySessionInfo] Updated PTY session information
+    def resize(pty_size)
+      raise Sdk::Error, 'No resize handler available' unless handle_resize
+
+      handle_resize.call(pty_size)
+    end
+
+    # Delete the PTY session
+    #
+    # @return [void]
+    def kill
+      raise Sdk::Error, 'No kill handler available' unless handle_kill
+
+      handle_kill.call
+    end
+
+    # Wait for the PTY session to complete
+    #
+    # @param on_data [Proc, nil] Optional callback to handle output data
+    # @return [Nightona::PtyResult] Result containing exit code and error information
+    def wait(timeout: nil, &on_data)
+      timeout ||= Float::INFINITY
+      return unless status == Status::CONNECTED
+
+      start_time = Time.now
+      add_observer(on_data, :call) if on_data
+
+      sleep(SLEEP_INTERVAL) while status == Status::CONNECTED && (Time.now - start_time) <= timeout
+
+      PtyResult.new(exit_code:, error:)
+    ensure
+      delete_observer(on_data) if on_data
+    end
+
+    # @yieldparam [WebSocket::Frame::Data]
+    # @return [void]
+    def each(&)
+      return unless block_given?
+
+      queue = Queue.new
+      add_observer(proc { queue << _1 }, :call)
+
+      while websocket.open?
+        drain(queue, &)
+        sleep(SLEEP_INTERVAL)
+      end
+
+      drain(queue, &)
+    end
+
+    # Disconnect from the PTY session
+    #
+    # @return [void]
+    def disconnect = websocket.close
+
+    private
+
+    # @return [Symbol]
+    attr_reader :status
+
+    # @return [WebSocket::Client::Simple::Client]
+    attr_reader :websocket
+
+    # @return [Proc, Nil]
+    attr_reader :handle_kill
+
+    # @return [Proc, Nil]
+    attr_reader :handle_resize
+
+    # @return [Logger]
+    attr_reader :logger
+
+    # @return [void]
+    def subscribe
+      websocket.on(:open, &method(:on_websocket_open))
+      websocket.on(:close, &method(:on_websocket_close))
+      websocket.on(:message, &method(:on_websocket_message))
+      websocket.on(:error, &method(:on_websocket_error))
+    end
+
+    # @return [void]
+    def on_websocket_open
+      logger.debug('[Websocket] open')
+      @status = Status::OPEN
+    end
+
+    # @param error [Object, Nil]
+    # @return [void]
+    def on_websocket_close(error)
+      logger.debug("[Websocket] close: #{error.inspect}")
+      @status = Status::CLOSED
+    end
+
+    # @param error [WebSocket::Frame::Incoming::Client]
+    # @return [void]
+    def on_websocket_message(message)
+      logger.debug("[Websocket] message(#{message.type}): #{message.data}")
+
+      case message.type
+      when :binary, :text
+        process_websocket_text_message(message)
+      when :close
+        process_websocket_close_message(message)
+      end
+    end
+
+    # @param error [Object]
+    # @return [void]
+    def on_websocket_error(error)
+      logger.debug("[Websocket] error: #{error.inspect}")
+      logger.debug("[Websocket] error: #{error.class}")
+      @status = Status::ERROR
+    end
+
+    # @param message [WebSocket::Frame::Incoming::Client]
+    # @return [void]
+    def process_websocket_text_message(message)
+      data = JSON.parse(message.data.to_s, symbolize_names: true)
+      process_websocket_control_message(data) if data[:type] == WebSocketMessageType::CONTROL
+    rescue JSON::ParserError, TypeError
+      process_websocket_data_message(message.data.to_s)
+    end
+
+    # @param data [WebSocket::Frame::Data]
+    # @return [void]
+    def process_websocket_data_message(data)
+      changed
+      notify_observers(data)
+    end
+
+    # @param data [WebSocket::Frame::Data]
+    # @return [void]
+    def process_websocket_control_message(data) # rubocop:disable Metrics/MethodLength
+      case data[:status]
+      when WebSocketControlStatus::CONNECTED
+        logger.debug('[control] connected')
+        @status = Status::CONNECTED
+      when WebSocketControlStatus::ERROR
+        logger.debug("[control] error: #{error.inspect}")
+        @status = Status::ERROR
+        @error = data.fetch(:error, 'Unknown connection error')
+      else
+        websocket.close
+        raise Sdk::Error, "Received invalid control message status: #{data[:status]}"
+      end
+    end
+
+    # @param message [WebSocket::Frame::Incoming::Client]
+    # @return [void]
+    def process_websocket_close_message(message)
+      data = JSON.parse(message.data.to_s, symbolize_names: true)
+      @exit_code = data.fetch(:exitCode, nil)
+      @error = data.fetch(:exitReason, nil)
+
+      disconnect
+    rescue JSON::ParserError, TypeError
+      nil
+    end
+
+    # @param queue [Queue]
+    # @yieldparam [WebSocket::Frame::Data]
+    # @return [void]
+    def drain(queue)
+      data = nil
+
+      yield data while (data = queue.pop(true))
+    rescue ThreadError => _e
+      nil
+    end
+
+    DEFAULT_TIMEOUT = 10.0
+    private_constant :DEFAULT_TIMEOUT
+
+    SLEEP_INTERVAL = 0.1
+    private_constant :SLEEP_INTERVAL
+
+    module Status
+      ALL = [
+        INIT = 'init',
+        OPEN = 'open',
+        CONNECTED = 'connected',
+        CLOSED = 'closed',
+        ERROR = 'error'
+      ].freeze
+    end
+
+    module WebSocketMessageType
+      ALL = [
+        CONTROL = 'control'
+      ].freeze
+    end
+
+    module WebSocketControlStatus
+      ALL = [
+        CONNECTED = 'connected',
+        ERROR = 'error'
+      ].freeze
+    end
+  end
+end