daytona-sdk 0.125.0

data/lib/daytona/code_toolbox/sandbox_ts_code_toolbox.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Daytona
+  class SandboxTsCodeToolbox
+    # Get the run command for executing TypeScript code
+    #
+    # @param code [String] The TypeScript code to execute
+    # @param params [Daytona::CodeRunParams, nil] Optional parameters for code execution
+    # @return [String] The command to run the TypeScript code
+    def get_run_command(code, params = nil)
+      encoded_code = Base64.encode64(code)
+
+      argv = params&.argv&.join(' ') || ''
+
+      # Execute TypeScript code using ts-node with ESM support
+      " sh -c 'echo #{encoded_code} | base64 --decode | npx ts-node -O " \
+        "\"{\\\"module\\\":\\\"CommonJS\\\"}\" -e \"$(cat)\" x #{argv} 2>&1 | grep -vE " \
+        "\"npm notice\"' "
+    end
+  end
+end

data/lib/daytona/common/charts.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+module Daytona
+  module Charts
+    # @param data [Hash<Symbol, Object>]
+    # @return [Daytona::Charts::Chart]
+    def self.parse(data)
+      case data.fetch(:type, ChartType::UNKNOWN)
+      when ChartType::LINE then LineChart.new(data)
+      when ChartType::SCATTER then ScatterChart.new(data)
+      when ChartType::BAR then BarChart.new(data)
+      when ChartType::PIE then PieChart.new(data)
+      when ChartType::BOX_AND_WHISKER then BoxAndWhiskerChart.new(data)
+      when ChartType::COMPOSITE_CHART then CompositeChart.new(data)
+      else
+        Chart.new(data)
+      end
+    end
+
+    class Chart
+      # @return [String, Nil] The type of chart
+      attr_reader :type
+
+      # @return [String, Nil] The title of the chart
+      attr_reader :title
+
+      # @return [Array<Object>] The elements of the chart
+      attr_reader :elements
+
+      # @return [String, Nil] The PNG representation of the chart encoded in base64
+      attr_reader :png
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        @type = data.fetch(:type, nil)
+        @title = data.fetch(:title, nil)
+        @elements = data.fetch(:elements, [])
+        @png = data.fetch(:png, nil)
+      end
+
+      # @return [Hash<Symbol, Object>] original metadata
+      def to_h = { type:, title:, elements:, png: }
+    end
+
+    class Chart2D < Chart
+      # @return [String, Nil] The label of the x-axis
+      attr_reader :x_label
+
+      # @return [String, Nil] The label of the y-axis
+      attr_reader :y_label
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        super
+        @x_label = data.fetch(:x_label, nil)
+        @y_label = data.fetch(:y_label, nil)
+      end
+
+      # @return [Hash<Symbol, Object>] original metadata
+      def to_h = super.merge(x_label:, y_label:)
+    end
+
+    class PointData
+      # @return [String] The label of the point series
+      attr_reader :label
+
+      # @return [Array<Array<Object>>] Array of [x, y] points
+      attr_reader :points
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        @label = data.fetch(:label)
+        @points = data.fetch(:points)
+      end
+
+      # @return [Hash<Symbol, Object>] original data representation
+      def to_h = { label:, points: }
+    end
+
+    class PointChart < Chart2D
+      # @return [Array<Object>] The ticks of the x-axis
+      attr_reader :x_ticks
+
+      # @return [Array<String>] The labels of the x-axis
+      attr_reader :x_tick_labels
+
+      # @return [String, Nil] The scale of the x-axis
+      attr_reader :x_scale
+
+      # @return [Array<Object>] The ticks of the y-axis
+      attr_reader :y_ticks
+
+      # @return [Array<String>] The labels of the y-axis
+      attr_reader :y_tick_labels
+
+      # @return [String, Nil] The scale of the y-axis
+      attr_reader :y_scale
+
+      # @return [Array<Daytona::Charts::PointData>] The points of the chart
+      attr_reader :elements
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        super
+        @x_scale = data.fetch(:x_scale, nil)
+        @x_ticks = data.fetch(:x_ticks, nil)
+        @x_tick_labels = data.fetch(:x_tick_labels, nil)
+
+        @y_scale = data.fetch(:y_scale, nil)
+        @y_ticks = data.fetch(:y_ticks, nil)
+        @y_tick_labels = data.fetch(:y_tick_labels, nil)
+
+        @elements = data.fetch(:elements, []).map { |e| PointData.new(e) }
+      end
+
+      # @return [Hash<Symbol, Object>] original metadata
+      def to_h
+        super.merge(
+          x_scale:,
+          x_ticks:,
+          x_tick_labels:,
+          y_scale:,
+          y_ticks:,
+          y_tick_labels:,
+          elements: elements.map(&:to_h)
+        )
+      end
+    end
+
+    class LineChart < PointChart
+      def initialize(data)
+        super
+        @type = ChartType::LINE
+      end
+    end
+
+    class ScatterChart < PointChart
+      def initialize(data)
+        super
+        @type = ChartType::SCATTER
+      end
+    end
+
+    class BarData
+      # @return [String] The label of the bar
+      attr_reader :label
+
+      # @return [String] The value of the bar
+      attr_reader :value
+
+      # @return [String] The group of the bar
+      attr_reader :group
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        @label = data.fetch(:label)
+        @value = data.fetch(:value)
+        @group = data.fetch(:group)
+      end
+
+      # @return [Hash<Symbol, Object>]
+      def to_h = { label:, value:, group: }
+    end
+
+    class BarChart < Chart2D
+      # @return [Array<Daytona::Charts::BarData>] The bars of the chart
+      attr_reader :elements
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        super
+        @type = ChartType::BAR
+        @elements = data.fetch(:elements, []).map { |e| BarData.new(e) }
+      end
+
+      # @return [Hash<Symbol, Object>]
+      def to_h = super.merge(elements: elements.map(&:to_h))
+    end
+
+    class PieData
+      # @return [String] The label of the pie slice
+      attr_reader :label
+
+      # @return [Float] The angle of the pie slice
+      attr_reader :angle
+
+      # @return [Float] The radius of the pie slice
+      attr_reader :radius
+
+      # @return [Float] The autopct value of the pie slice
+      attr_reader :autopct
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        @label = data.fetch(:label)
+        @angle = data.fetch(:angle)
+        @radius = data.fetch(:radius)
+        @autopct = data.fetch(:autopct)
+      end
+
+      # @return [Hash<Symbol, Object>]
+      def to_h = { label:, angle:, radius:, autopct: }
+    end
+
+    class PieChart < Chart
+      # @return [Array<Daytona::Charts::PieData>] The pie slices of the chart
+      attr_reader :elements
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        super
+        @type = ChartType::PIE
+        @elements = data.fetch(:elements, []).map { |e| PieData.new(e) }
+      end
+
+      # @return [Hash<Symbol, Object>]
+      def to_h = super.merge(elements: elements.map(&:to_h))
+    end
+
+    class BoxAndWhiskerData
+      # @return [String] The label of the box and whisker
+      attr_reader :label
+
+      # @return [Float] The minimum value of the box and whisker
+      attr_reader :min
+
+      # @return [Float] The first quartile of the box and whisker
+      attr_reader :first_quartile
+
+      # @return [Float] The median of the box and whisker
+      attr_reader :median
+
+      # @return [Float] The third quartile of the box and whisker
+      attr_reader :third_quartile
+
+      # @return [Float] The maximum value of the box and whisker
+      attr_reader :max
+
+      # @return [Array<Float>] The outliers of the box and whisker
+      attr_reader :outliers
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        @label = data.fetch(:label)
+        @min = data.fetch(:min)
+        @first_quartile = data.fetch(:first_quartile)
+        @median = data.fetch(:median)
+        @third_quartile = data.fetch(:third_quartile)
+        @max = data.fetch(:max)
+        @outliers = data.fetch(:outliers, [])
+      end
+
+      # @return [Hash<Symbol, Object>]
+      def to_h = { label:, min:, first_quartile:, median:, third_quartile:, max:, outliers: }
+    end
+
+    class BoxAndWhiskerChart < Chart2D
+      # @return [Array<Daytona::Charts::BoxAndWhiskerData>] The box and whiskers of the chart
+      attr_reader :elements
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        super
+        @type = ChartType::BOX_AND_WHISKER
+        @elements = data.fetch(:elements, []).map { |e| BoxAndWhiskerData.new(e) }
+      end
+
+      # @return [Hash<Symbol, Object>]
+      def to_h = super.merge(elements: elements.map(&:to_h))
+    end
+
+    class CompositeChart < Chart
+      # @return [Array<Daytona::Charts::Chart>] The charts of the composite chart
+      attr_reader :elements
+
+      # @param data [Hash<Symbol, Object>]
+      def initialize(data)
+        super
+        @type = ChartType::COMPOSITE_CHART
+        @elements = data.fetch(:elements, []).map { |e| Charts.parse(e) }
+      end
+
+      def to_h = super.merge(elements: elements.map(&:to_h))
+    end
+
+    module ChartType
+      ALL = [
+        LINE = 'line',
+        SCATTER = 'scatter',
+        BAR = 'bar',
+        PIE = 'pie',
+        BOX_AND_WHISKER = 'box_and_whisker',
+        COMPOSITE_CHART = 'composite_chart',
+        UNKNOWN = 'unknown'
+      ].freeze
+    end
+  end
+end

data/lib/daytona/common/code_language.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Daytona
+  module CodeLanguage
+    ALL = [
+      JAVASCRIPT = :javascript,
+      PYTHON = :python,
+      TYPESCRIPT = :typescript
+    ].freeze
+  end
+end

data/lib/daytona/common/daytona.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Daytona
+  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<DaytonaApiClient::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 [Boolean, nil] Whether the Sandbox should be ephemeral
+    attr_accessor :ephemeral
+
+    # 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<DaytonaApiClient::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 ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    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,
+      ephemeral: 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
+      @ephemeral = ephemeral
+
+      # 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:,
+        ephemeral:
+      }.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 [Daytona::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 [Daytona::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<DaytonaApiClient::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 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<DaytonaApiClient::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 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/daytona/common/file_system.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Daytona
+  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/daytona/common/git.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Daytona
+  # 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