nightona 0.191.0

data/lib/nightona/code_interpreter.rb

@@ -0,0 +1,359 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'json'
+require 'websocket-client-simple'
+require 'timeout'
+
+module Nightona
+  # Handles code interpretation and execution within a Sandbox. Currently supports only Python.
+  #
+  # This class provides methods to execute code in isolated interpreter contexts,
+  # manage contexts, and stream execution output via callbacks. If subsequent code executions
+  # are performed in the same context, the variables, imports, and functions defined in
+  # the previous execution will be available.
+  #
+  # For other languages, use the `code_run` method from the `Process` interface,
+  # or execute the appropriate command directly in the sandbox terminal.
+  class CodeInterpreter
+    include Instrumentation
+
+    WEBSOCKET_TIMEOUT_CODE = 4008
+    WS_PORT = 2280
+    private_constant :WS_PORT
+
+    # @param sandbox_id [String]
+    # @param toolbox_api [NightonaToolboxApiClient::InterpreterApi]
+    # @param get_preview_link [Proc]
+    # @param otel_state [Nightona::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, get_preview_link:, otel_state: nil)
+      @sandbox_id = sandbox_id
+      @toolbox_api = toolbox_api
+      @get_preview_link = get_preview_link
+      @otel_state = otel_state
+    end
+
+    # Execute Python code in the sandbox.
+    #
+    # By default, code runs in the default shared context which persists variables,
+    # imports, and functions across executions. To run in an isolated context,
+    # create a new context with `create_context` and pass it as the `context` argument.
+    #
+    # @param code [String] Code to execute
+    # @param context [NightonaToolboxApiClient::InterpreterContext, nil] Context to run code in
+    # @param on_stdout [Proc, nil] Callback for stdout messages (receives OutputMessage)
+    # @param on_stderr [Proc, nil] Callback for stderr messages (receives OutputMessage)
+    # @param on_error [Proc, nil] Callback for execution errors (receives ExecutionError)
+    # @param envs [Hash<String, String>, nil] Environment variables for this execution
+    # @param timeout [Integer, nil] Timeout in seconds. 0 means no timeout. Default is 10 minutes.
+    # @return [Nightona::ExecutionResult]
+    # @raise [Nightona::Sdk::Error]
+    #
+    # @example
+    #   def handle_stdout(msg)
+    #     print "STDOUT: #{msg.output}"
+    #   end
+    #
+    #   def handle_stderr(msg)
+    #     print "STDERR: #{msg.output}"
+    #   end
+    #
+    #   def handle_error(err)
+    #     puts "ERROR: #{err.name}: #{err.value}"
+    #   end
+    #
+    #   code = <<~PYTHON
+    #     import sys
+    #     import time
+    #     for i in range(5):
+    #         print(i)
+    #         time.sleep(1)
+    #     sys.stderr.write("Counting done!")
+    #   PYTHON
+    #
+    #   result = sandbox.code_interpreter.run_code(
+    #     code,
+    #     on_stdout: method(:handle_stdout),
+    #     on_stderr: method(:handle_stderr),
+    #     on_error: method(:handle_error),
+    #     timeout: 10
+    #   )
+    def run_code(code, context: nil, on_stdout: nil, on_stderr: nil, on_error: nil, envs: nil, timeout: nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/ParameterLists
+      # Get WebSocket URL via preview link
+      preview_link = @get_preview_link.call(WS_PORT)
+      url = URI.parse(preview_link.url)
+      url.scheme = url.scheme == 'https' ? 'wss' : 'ws'
+      url.path = '/process/interpreter/execute'
+      ws_url = url.to_s
+
+      result = ExecutionResult.new
+
+      # Create request payload
+      request = { code: }
+      request[:contextId] = context.id if context
+      request[:envs] = envs if envs
+      request[:timeout] = timeout if timeout
+
+      # Build headers with preview token
+      headers = @toolbox_api.api_client.default_headers.dup.merge(
+        'X-Nightona-Preview-Token' => preview_link.token,
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json'
+      )
+
+      completion_queue = Queue.new
+      interpreter = self
+
+      puts "[DEBUG] Connecting to WebSocket: #{ws_url}" if ENV['DEBUG']
+
+      ws = WebSocket::Client::Simple.connect(ws_url, headers:) do |client|
+        client.on :open do
+          puts '[DEBUG] WebSocket opened, sending request' if ENV['DEBUG']
+          client.send(JSON.dump(request))
+        end
+
+        client.on :message do |msg|
+          puts "[DEBUG] Received message (length=#{msg.data.length}): #{msg.data.inspect[0..200]}" if ENV['DEBUG']
+
+          interpreter.send(:handle_message, msg.data, result, on_stdout, on_stderr, on_error, completion_queue)
+        end
+
+        client.on :error do |e|
+          puts "[DEBUG] WebSocket error: #{e.message}" if ENV['DEBUG']
+          completion_queue.push({ type: :error, error: e })
+        end
+
+        client.on :close do |e|
+          if ENV['DEBUG']
+            code = e&.code || 'nil'
+            reason = e&.reason || 'nil'
+            puts "[DEBUG] WebSocket closed: code=#{code}, reason=#{reason}"
+          end
+          error_info = interpreter.send(:handle_close, e)
+          if error_info
+            completion_queue.push({ type: :error_from_close, error: error_info })
+          else
+            completion_queue.push({ type: :close })
+          end
+        end
+      end
+
+      no_timeout = timeout.is_a?(Numeric) && timeout <= 0
+      max_wait = no_timeout ? nil : (timeout || 600) + 30
+      start_time = Time.now
+      completion_reason = nil
+
+      loop do
+        if max_wait
+          remaining = max_wait - (Time.now - start_time)
+          if remaining <= 0
+            ws.close
+            raise Sdk::TimeoutError,
+                  'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
+          end
+        end
+
+        completion = completion_queue.pop(timeout: max_wait ? remaining : nil)
+
+        if completion.nil?
+          ws.close
+          raise Sdk::TimeoutError,
+                'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
+        end
+
+        puts "[DEBUG] Got completion signal: #{completion[:type]}" if ENV['DEBUG']
+
+        if completion[:type] == :completed
+          completion_reason = :completed
+          break
+        elsif completion[:type] == :error_from_close
+          error_msg = completion[:error]
+          if error_msg.include?('timed out') || error_msg.include?('Execution timed out')
+            raise Sdk::TimeoutError, error_msg
+          end
+
+          raise Sdk::Error, error_msg
+        elsif completion[:type] == :close
+          elapsed = Time.now - start_time
+          if timeout && timeout > 0 && elapsed >= timeout && elapsed < (timeout + 2)
+            raise Sdk::TimeoutError,
+                  'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
+          end
+          completion_reason = :close
+          break
+        elsif completion[:type] == :error
+          unless completion[:error].message.include?('stream closed')
+            raise Sdk::Error, "WebSocket error: #{completion[:error].message}"
+          end
+
+          completion_reason = :close
+          break
+        end
+      end
+
+      ws.close if completion_reason != :close
+      sleep 0.05
+
+      result
+    rescue Sdk::Error
+      # Re-raise SDK errors as-is
+      raise
+    rescue StandardError => e
+      # Wrap unexpected errors
+      raise Sdk::Error, "Failed to run code: #{e.message}"
+    end
+
+    # Create a new isolated interpreter context.
+    #
+    # Contexts provide isolated execution environments with their own global namespace.
+    # Variables, imports, and functions defined in one context don't affect others.
+    #
+    # @param cwd [String, nil] Working directory for the context
+    # @return [NightonaToolboxApiClient::InterpreterContext]
+    # @raise [Nightona::Sdk::Error]
+    #
+    # @example
+    #   # Create isolated context
+    #   ctx = sandbox.code_interpreter.create_context
+    #
+    #   # Execute code in this context
+    #   sandbox.code_interpreter.run_code("x = 100", context: ctx)
+    #
+    #   # Variable only exists in this context
+    #   result = sandbox.code_interpreter.run_code("print(x)", context: ctx)  # OK
+    #
+    #   # Won't see the variable in default context
+    #   result = sandbox.code_interpreter.run_code("print(x)")  # NameError
+    #
+    #   # Clean up
+    #   sandbox.code_interpreter.delete_context(ctx)
+    def create_context(cwd: nil)
+      request = NightonaToolboxApiClient::CreateContextRequest.new(cwd:)
+      @toolbox_api.create_interpreter_context(request)
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to create interpreter context: #{e.message}"
+    end
+
+    # List all user-created interpreter contexts.
+    #
+    # The default context is not included in this list. Only contexts created
+    # via `create_context` are returned.
+    #
+    # @return [Array<NightonaToolboxApiClient::InterpreterContext>]
+    # @raise [Nightona::Sdk::Error]
+    #
+    # @example
+    #   contexts = sandbox.code_interpreter.list_contexts
+    #   contexts.each do |ctx|
+    #     puts "Context #{ctx.id}: #{ctx.language} at #{ctx.cwd}"
+    #   end
+    def list_contexts
+      response = @toolbox_api.list_interpreter_contexts
+      response.contexts || []
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to list interpreter contexts: #{e.message}"
+    end
+
+    # Delete an interpreter context and shut down all associated processes.
+    #
+    # This permanently removes the context and all its state (variables, imports, etc.).
+    # The default context cannot be deleted.
+    #
+    # @param context [NightonaToolboxApiClient::InterpreterContext]
+    # @return [void]
+    # @raise [Nightona::Sdk::Error]
+    #
+    # @example
+    #   ctx = sandbox.code_interpreter.create_context
+    #   # ... use context ...
+    #   sandbox.code_interpreter.delete_context(ctx)
+    def delete_context(context)
+      @toolbox_api.delete_interpreter_context(context.id)
+      nil
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to delete interpreter context: #{e.message}"
+    end
+
+    instrument :run_code, :create_context, :list_contexts, :delete_context,
+               component: 'CodeInterpreter'
+
+    private
+
+    # @return [Nightona::OtelState, nil]
+    attr_reader :otel_state
+
+    # @return [Hash<String, String>]
+    def build_headers
+      headers = {}
+      @toolbox_api.api_client.update_params_for_auth!(headers, nil, ['bearer'])
+      headers
+    end
+
+    # @param data [String]
+    # @param result [Nightona::ExecutionResult]
+    # @param on_stdout [Proc, nil]
+    # @param on_stderr [Proc, nil]
+    # @param on_error [Proc, nil]
+    # @param completion_queue [Queue, nil] Queue to signal completion
+    # @return [void]
+    def handle_message(data, result, on_stdout, on_stderr, on_error, completion_queue = nil) # rubocop:disable Metrics/AbcSize, Metrics/ParameterLists
+      # Empty messages are just keepalives or noise, ignore them
+      if data.nil? || data.empty?
+        puts '[DEBUG] Received empty message, ignoring' if ENV['DEBUG']
+        return
+      end
+
+      chunk = JSON.parse(data)
+      chunk_type = chunk['type']
+
+      case chunk_type
+      when 'stdout'
+        stdout = chunk['text'] || ''
+        result.stdout += stdout
+        on_stdout&.call(OutputMessage.new(output: stdout))
+      when 'stderr'
+        stderr = chunk['text'] || ''
+        result.stderr += stderr
+        on_stderr&.call(OutputMessage.new(output: stderr))
+      when 'error'
+        error = ExecutionError.new(
+          name: chunk['name'] || '',
+          value: chunk['value'] || '',
+          traceback: chunk['traceback'] || ''
+        )
+        result.error = error
+        on_error&.call(error)
+      when 'control'
+        control_text = chunk['text'] || ''
+        if %w[completed interrupted].include?(control_text)
+          puts "[DEBUG] Received control message: #{control_text}" if ENV['DEBUG']
+          completion_queue&.push({ type: :completed })
+        end
+      end
+    rescue JSON::ParserError => e
+      # Skip malformed messages
+      warn "Warning: Failed to parse message: #{e.message}" if ENV['DEBUG']
+    end
+
+    # @param event [Object]
+    # @return [void]
+    def handle_close(event)
+      return nil unless event # Skip if event is nil (manual close)
+
+      code = event.respond_to?(:code) ? event.code : nil
+      reason = event.respond_to?(:reason) ? event.reason : nil
+
+      if code == WEBSOCKET_TIMEOUT_CODE
+        return 'Execution timed out: operation exceeded the configured `timeout`. Provide a larger value if needed.'
+      end
+
+      return nil if code == 1000 || code.nil? # Normal closure or no code
+
+      detail = reason.to_s.empty? ? 'WebSocket connection closed unexpectedly' : reason.to_s
+      detail = "#{detail} (close code #{code})" if code
+      detail
+    end
+  end
+end

data/lib/nightona/common/charts.rb

@@ -0,0 +1,124 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  ChartElement = NightonaToolboxApiClient::ChartElement
+
+  module ChartType
+    LINE = 'line'
+    SCATTER = 'scatter'
+    BAR = 'bar'
+    PIE = 'pie'
+    BOX_AND_WHISKER = 'box_and_whisker'
+    COMPOSITE_CHART = 'composite_chart'
+    UNKNOWN = 'unknown'
+  end
+
+  PointData = Struct.new(:label, :points, keyword_init: true)
+  BarData = Struct.new(:label, :value, :group, keyword_init: true)
+  PieData = Struct.new(:label, :angle, :radius, keyword_init: true)
+  BoxAndWhiskerData = Struct.new(:label, :min, :first_quartile, :median, :third_quartile, :max, :outliers,
+                                 keyword_init: true)
+
+  Chart = Struct.new(:type, :title, :png, :elements, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [])
+      super
+    end
+  end
+
+  Chart2D = Struct.new(:type, :title, :png, :elements, :x_label, :y_label, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [], x_label: nil, y_label: nil)
+      super
+    end
+  end
+
+  PointChart = Struct.new(:type, :title, :png, :elements, :x_label, :y_label,
+                          :x_ticks, :y_ticks, :x_tick_labels, :y_tick_labels,
+                          :x_scale, :y_scale, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [], x_label: nil, y_label: nil,
+                   x_ticks: nil, y_ticks: nil, x_tick_labels: nil, y_tick_labels: nil,
+                   x_scale: nil, y_scale: nil)
+      super
+    end
+  end
+
+  class LineChart < PointChart
+  end
+
+  class ScatterChart < PointChart
+  end
+
+  class BarChart < Chart2D
+  end
+
+  class PieChart < Chart
+  end
+
+  class BoxAndWhiskerChart < Chart2D
+  end
+
+  class CompositeChart < Chart
+  end
+
+  module Charts
+    Chart = Nightona::Chart
+    ChartElement = Nightona::ChartElement
+    ChartType = Nightona::ChartType
+    LineChart = Nightona::LineChart
+    ScatterChart = Nightona::ScatterChart
+    BarChart = Nightona::BarChart
+    PieChart = Nightona::PieChart
+    BoxAndWhiskerChart = Nightona::BoxAndWhiskerChart
+    CompositeChart = Nightona::CompositeChart
+    PointData = Nightona::PointData
+    BarData = Nightona::BarData
+    PieData = Nightona::PieData
+    BoxAndWhiskerData = Nightona::BoxAndWhiskerData
+
+    def self.parse_chart(chart)
+      type = chart.type || ChartType::UNKNOWN
+      elements = (chart.elements || []).map { |el| map_element(el, type) }
+      common = { type: chart.type, title: chart.title, png: chart.png, elements: elements }
+
+      case type
+      when ChartType::LINE
+        LineChart.new(x_label: chart.x_label, y_label: chart.y_label, x_ticks: chart.x_ticks, y_ticks: chart.y_ticks,
+                      x_tick_labels: chart.x_tick_labels, y_tick_labels: chart.y_tick_labels,
+                      x_scale: chart.x_scale, y_scale: chart.y_scale, **common)
+      when ChartType::SCATTER
+        ScatterChart.new(x_label: chart.x_label, y_label: chart.y_label, x_ticks: chart.x_ticks, y_ticks: chart.y_ticks,
+                         x_tick_labels: chart.x_tick_labels, y_tick_labels: chart.y_tick_labels,
+                         x_scale: chart.x_scale, y_scale: chart.y_scale, **common)
+      when ChartType::BAR
+        BarChart.new(x_label: chart.x_label, y_label: chart.y_label, **common)
+      when ChartType::PIE
+        PieChart.new(**common)
+      when ChartType::BOX_AND_WHISKER
+        BoxAndWhiskerChart.new(x_label: chart.x_label, y_label: chart.y_label, **common)
+      when ChartType::COMPOSITE_CHART
+        CompositeChart.new(**common)
+      else
+        Chart.new(**common)
+      end
+    end
+
+    def self.map_element(el, chart_type)
+      case chart_type
+      when ChartType::LINE, ChartType::SCATTER
+        PointData.new(label: el.label, points: el.points)
+      when ChartType::BAR
+        BarData.new(label: el.label, value: el.value, group: el.group)
+      when ChartType::PIE
+        PieData.new(label: el.label, angle: el.angle, radius: el.radius)
+      when ChartType::BOX_AND_WHISKER
+        BoxAndWhiskerData.new(label: el.label, min: el.min, first_quartile: el.first_quartile,
+                              median: el.median, third_quartile: el.third_quartile,
+                              max: el.max, outliers: el.outliers)
+      else
+        el
+      end
+    end
+  end
+end

data/lib/nightona/common/code_interpreter.rb

@@ -0,0 +1,56 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  # Represents stdout or stderr output from code execution
+  class OutputMessage
+    # @return [String] The output content
+    attr_reader :output
+
+    # @param output [String]
+    def initialize(output:)
+      @output = output
+    end
+  end
+
+  # Represents an error that occurred during code execution
+  class ExecutionError
+    # @return [String] The error type/class name (e.g., "ValueError", "SyntaxError")
+    attr_reader :name
+
+    # @return [String] The error value
+    attr_reader :value
+
+    # @return [String] Full traceback of the error
+    attr_reader :traceback
+
+    # @param name [String]
+    # @param value [String]
+    # @param traceback [String]
+    def initialize(name:, value:, traceback: '')
+      @name = name
+      @value = value
+      @traceback = traceback
+    end
+  end
+
+  # Result of code execution
+  class ExecutionResult
+    # @return [String] Standard output from the code execution
+    attr_accessor :stdout
+
+    # @return [String] Standard error output from the code execution
+    attr_accessor :stderr
+
+    # @return [ExecutionError, nil] Error details if execution failed, nil otherwise
+    attr_accessor :error
+
+    def initialize(stdout: '', stderr: '', error: nil)
+      @stdout = stdout
+      @stderr = stderr
+      @error = error
+    end
+  end
+end

data/lib/nightona/common/code_language.rb

@@ -0,0 +1,14 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  module CodeLanguage
+    ALL = [
+      JAVASCRIPT = :javascript,
+      PYTHON = :python,
+      TYPESCRIPT = :typescript
+    ].freeze
+  end
+end

data/lib/nightona/common/file_system.rb

@@ -0,0 +1,26 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  class FileUpload
+    # @return [String, IO] File contents as a string/bytes object or a local file path or IO object.
+    #   If a string path is provided, the file content will be read from disk.
+    #   If a string content is provided, make sure it fits into memory.
+    attr_reader :source
+
+    # @return [String] Absolute destination path in the Sandbox. Relative paths are resolved based on
+    #   the sandbox working directory.
+    attr_reader :destination
+
+    # Initializes a new FileUpload instance.
+    #
+    # @param source [String, IO] File contents as a string/bytes object or a local file path or IO object.
+    # @param destination [String] Absolute destination path in the Sandbox.
+    def initialize(source, destination)
+      @source = source
+      @destination = destination
+    end
+  end
+end

data/lib/nightona/common/git.rb

@@ -0,0 +1,19 @@
+# Copyright Daytona Platforms Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Nightona
+  # Response from the git commit.
+  class GitCommitResponse
+    # @return [String] The SHA of the commit
+    attr_reader :sha
+
+    # Initialize a new GitCommitResponse
+    #
+    # @param sha [String] The SHA of the commit
+    def initialize(sha:)
+      @sha = sha
+    end
+  end
+end