daytona 0.163.0 → 0.164.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c80d82abdea9151dd32d9e78672eeed2599929431f1eed2492eefd74a7ae69da
-  data.tar.gz: 1a07f8be5ea538e100e7dbcf246eca724cc086bc5a60588e650b31412b234c89
+  metadata.gz: 064c93ac0f9ef2c0bebd53497d5f86584f8a75b684cad9029575d1a7efa37f48
+  data.tar.gz: c61d029c96aca2d15f62d3dec3de189d3741902bc5f818d1e07aa535f591bbe6
 SHA512:
-  metadata.gz: d987d6679b98e3d5e259fe65b91e898d83e7ed75d4d16e82f1e7147c9b0a3c0ea7fbbf97b5d66d300ad87951fe6487ab75a61f2b69c45bf72f1c2b615e9a9603
-  data.tar.gz: '07967504fa22e9bb43baaf68685b0ddbac35184d753155bc589c58fb6bfe12e1c76201bcb862d13c1f606845d02a738e896021e8407fe372524bf0e1bb5f7821'
+  metadata.gz: e26f87d3f2a68b701a07ea391adcf0c3a3316f0ac19d06ee8d4381629f223b640410950b5a8454592cf2a2634b3204bdcb5b39852414fab46ef5e0a0701bdf1b
+  data.tar.gz: dbb7d8482d32949673de9fb43a68544d0219c46de4905a21f187e37eb482a5dc44312cec6ccc94f6075e28ed946ed947d608a7774029a3ed41fb715a48b63e4d

data/lib/daytona/common/charts.rb

@@ -1,298 +1,121 @@
 # 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
+  ChartElement = DaytonaToolboxApiClient::ChartElement
+
+  module ChartType
+    LINE = 'line'
+    SCATTER = 'scatter'
+    BAR = 'bar'
+    PIE = 'pie'
+    BOX_AND_WHISKER = 'box_and_whisker'
+    COMPOSITE_CHART = 'composite_chart'
+    UNKNOWN = 'unknown'
+  end
 
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @type = ChartType::BAR
-        @elements = data.fetch(:elements, []).map { |e| BarData.new(e) }
-      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)
 
-      # @return [Hash<Symbol, Object>]
-      def to_h = super.merge(elements: elements.map(&:to_h))
+  Chart = Struct.new(:type, :title, :png, :elements, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [])
+      super
     end
+  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: }
+  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
 
-    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))
+  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 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
+  class LineChart < PointChart
+  end
 
-      # @return [Float] The maximum value of the box and whisker
-      attr_reader :max
+  class ScatterChart < PointChart
+  end
 
-      # @return [Array<Float>] The outliers of the box and whisker
-      attr_reader :outliers
+  class BarChart < Chart2D
+  end
 
-      # @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
+  class PieChart < Chart
+  end
 
-      # @return [Hash<Symbol, Object>]
-      def to_h = { label:, min:, first_quartile:, median:, third_quartile:, max:, outliers: }
-    end
+  class BoxAndWhiskerChart < Chart2D
+  end
 
-    class BoxAndWhiskerChart < Chart2D
-      # @return [Array<Daytona::Charts::BoxAndWhiskerData>] The box and whiskers of the chart
-      attr_reader :elements
+  class CompositeChart < Chart
+  end
 
-      # @param data [Hash<Symbol, Object>]
-      def initialize(data)
-        super
-        @type = ChartType::BOX_AND_WHISKER
-        @elements = data.fetch(:elements, []).map { |e| BoxAndWhiskerData.new(e) }
+  module Charts
+    Chart = Daytona::Chart
+    ChartElement = Daytona::ChartElement
+    ChartType = Daytona::ChartType
+    LineChart = Daytona::LineChart
+    ScatterChart = Daytona::ScatterChart
+    BarChart = Daytona::BarChart
+    PieChart = Daytona::PieChart
+    BoxAndWhiskerChart = Daytona::BoxAndWhiskerChart
+    CompositeChart = Daytona::CompositeChart
+    PointData = Daytona::PointData
+    BarData = Daytona::BarData
+    PieData = Daytona::PieData
+    BoxAndWhiskerData = Daytona::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
-
-      # @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) }
+    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
-
-      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/daytona.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module Daytona
+  CODE_TOOLBOX_LANGUAGE_LABEL = 'code-toolbox-language'
+
   class CreateSandboxBaseParams
     # @return [Symbol, nil] Programming language for the Sandbox
     attr_accessor :language

data/lib/daytona/daytona.rb

@@ -66,6 +66,11 @@ module Daytona
         params.language = CodeLanguage::PYTHON
       end
 
+      unless CodeLanguage::ALL.include?(params.language.to_s.to_sym)
+        raise ArgumentError,
+              "Invalid #{CODE_TOOLBOX_LANGUAGE_LABEL}: #{params.language}. Supported languages: #{CodeLanguage::ALL.join(', ')}"
+      end
+
       _create(params, on_snapshot_create_logs:)
     end
 
@@ -81,7 +86,7 @@ module Daytona
     # @return [Daytona::Sandbox]
     def get(id)
       sandbox_dto = sandbox_api.get_sandbox(id)
-      to_sandbox(sandbox_dto:, code_toolbox: code_toolbox_from_labels(sandbox_dto.labels))
+      to_sandbox(sandbox_dto:)
     end
 
     # Lists Sandboxes filtered by labels.
@@ -102,10 +107,8 @@ module Daytona
         total: response.total,
         page: response.page,
         total_pages: response.total_pages,
-        items: response
-               .items
-               .map do |sandbox_dto|
-                 to_sandbox(sandbox_dto:, code_toolbox: code_toolbox_from_labels(sandbox_dto.labels))
+        items: response.items.map do |sandbox_dto|
+          to_sandbox(sandbox_dto:)
         end
       )
     end
@@ -150,7 +153,7 @@ module Daytona
       end
 
       labels = params.labels&.dup || {}
-      labels[LABEL_CODE_TOOLBOX_LANGUAGE] = params.language.to_s if params.language
+      labels[CODE_TOOLBOX_LANGUAGE_LABEL] = params.language.to_s if params.language
 
       create_sandbox = DaytonaApiClient::CreateSandbox.new(
         user: params.os_user,
@@ -204,7 +207,7 @@ module Daytona
         Util.stream_async(uri:, headers:, on_chunk: on_snapshot_create_logs)
       end
 
-      sandbox = to_sandbox(sandbox_dto: response, code_toolbox: code_toolbox_from_labels(response.labels))
+      sandbox = to_sandbox(sandbox_dto: response)
 
       if sandbox.state != DaytonaApiClient::SandboxState::STARTED
         sandbox.wait_for_sandbox_start([0.001, timeout - (Time.now - start_time)].max)
@@ -246,42 +249,16 @@ module Daytona
     end
 
     # @param sandbox_dto [DaytonaApiClient::Sandbox]
-    # @param code_toolbox [Daytona::SandboxPythonCodeToolbox, Daytona::SandboxTsCodeToolbox]
     # @return [Daytona::Sandbox]
-    def to_sandbox(sandbox_dto:, code_toolbox:)
+    def to_sandbox(sandbox_dto:)
       Sandbox.new(
         sandbox_dto:,
         config:,
         sandbox_api:,
-        code_toolbox:,
         otel_state: @otel_state
       )
     end
 
-    # Converts a language to a code toolbox
-    #
-    # @param language [Symbol]
-    # @return [Daytona::CodeToolbox]
-    # @raise [Daytona::Sdk::Error] If the language is not supported
-    def code_toolbox_from_language(language)
-      case language
-      when CodeLanguage::PYTHON, nil
-        SandboxPythonCodeToolbox.new
-      when SandboxTsCodeToolbox, CodeLanguage::TYPESCRIPT
-        SandboxTsCodeToolbox.new
-      when CodeLanguage::JAVASCRIPT
-        SandboxJsCodeToolbox.new
-      else
-        raise Sdk::Error, "Unsupported language: #{language}"
-      end
-    end
-
-    # Get code toolbox from Sandbox labels
-    #
-    # @param labels [Hash<String, String>]
-    # @return [Daytona::CodeToolbox]
-    def code_toolbox_from_labels(labels) = code_toolbox_from_language(labels[LABEL_CODE_TOOLBOX_LANGUAGE]&.to_sym)
-
     SOURCE_RUBY = 'sdk-ruby'
     private_constant :SOURCE_RUBY
 
@@ -293,8 +270,5 @@ module Daytona
 
     HEADER_ORGANIZATION_ID = 'X-Daytona-Organization-ID'
     private_constant :HEADER_ORGANIZATION_ID
-
-    LABEL_CODE_TOOLBOX_LANGUAGE = 'code-toolbox-language'
-    private_constant :LABEL_CODE_TOOLBOX_LANGUAGE
   end
 end

data/lib/daytona/process.rb

@@ -1,16 +1,11 @@
 # frozen_string_literal: true
 
-require 'base64'
-require 'json'
 require 'uri'
 
 module Daytona
   class Process # rubocop:disable Metrics/ClassLength
     include Instrumentation
 
-    # @return [Daytona::SandboxPythonCodeToolbox,
-    attr_reader :code_toolbox
-
     # @return [String] The ID of the Sandbox
     attr_reader :sandbox_id
 
@@ -20,18 +15,21 @@ module Daytona
     # @return [Proc] Function to get preview link for a port
     attr_reader :get_preview_link
 
+    # @return [String] The language for code execution (e.g. 'python', 'typescript', 'javascript')
+    attr_reader :language
+
     # Initialize a new Process instance
     #
-    # @param code_toolbox [Daytona::SandboxPythonCodeToolbox, Daytona::SandboxTsCodeToolbox]
     # @param sandbox_id [String] The ID of the Sandbox
     # @param toolbox_api [DaytonaToolboxApiClient::ProcessApi] API client for Sandbox operations
     # @param get_preview_link [Proc] Function to get preview link for a port
+    # @param language [String] The language for code execution
     # @param otel_state [Daytona::OtelState, nil]
-    def initialize(code_toolbox:, sandbox_id:, toolbox_api:, get_preview_link:, otel_state: nil)
-      @code_toolbox = code_toolbox
+    def initialize(sandbox_id:, toolbox_api:, get_preview_link:, language: 'python', otel_state: nil)
       @sandbox_id = sandbox_id
       @toolbox_api = toolbox_api
       @get_preview_link = get_preview_link
+      @language = language
       @otel_state = otel_state
     end
 
@@ -54,7 +52,8 @@ module Daytona
     #
     #   # Command with timeout
     #   result = sandbox.process.exec("sleep 10", timeout: 5)
-    def exec(command:, cwd: nil, env: nil, timeout: nil) # rubocop:disable Metrics/MethodLength
+    def exec(command:, cwd: nil, env: nil, timeout: nil)
+      envs = nil
       if env && !env.empty?
         env.each_key do |key|
           unless key.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
@@ -62,21 +61,16 @@ module Daytona
                   "Invalid environment variable name: '#{key}'"
           end
         end
-        safe_env_exports = env.map do |key, value|
-          "export #{key}=\"$(printf '%s' '#{Base64.strict_encode64(value)}' | base64 -d)\""
-        end.join('; ')
-        command = "#{safe_env_exports}; #{command}"
+        envs = env
       end
 
-      response = toolbox_api.execute_command(DaytonaToolboxApiClient::ExecuteRequest.new(command:, cwd:, timeout:))
-      # Post-process the output to extract ExecutionArtifacts
-      artifacts = parse_output(response.result.split("\n", -1))
-
-      # Create new response with processed output and charts
+      response = toolbox_api.execute_command(DaytonaToolboxApiClient::ExecuteRequest.new(command:, cwd:, envs:,
+                                                                                         timeout:))
+      result = response.result || ''
       ExecuteResponse.new(
         exit_code: response.exit_code,
-        result: artifacts.stdout,
-        artifacts: artifacts
+        result:,
+        artifacts: ExecutionArtifacts.new(result, [])
       )
     end
 
@@ -96,7 +90,19 @@ module Daytona
     #   CODE
     #   puts response.artifacts.stdout  # Prints: Sum: 30
     def code_run(code:, params: nil, timeout: nil)
-      exec(command: code_toolbox.get_run_command(code, params), env: params&.env, timeout:)
+      response = toolbox_api.code_run(
+        DaytonaToolboxApiClient::CodeRunRequest.new(
+          code:, language:, argv: params&.argv, envs: params&.env, timeout:
+        )
+      )
+
+      ExecuteResponse.new(
+        exit_code: response.exit_code,
+        result: response.result,
+        artifacts: ExecutionArtifacts.new(response.result, (response.artifacts&.charts || []).map do |c|
+          Charts.parse_chart(c)
+        end)
+      )
     end
 
     # Creates a new long-running background session in the Sandbox
@@ -186,15 +192,12 @@ module Daytona
                                                            suppress_input_echo: req.suppress_input_echo)
       )
 
-      stdout, stderr = Util.demux(response.output || '')
-
       SessionExecuteResponse.new(
         cmd_id: response.cmd_id,
         output: response.output,
-        stdout:,
-        stderr:,
+        stdout: response.stdout || '',
+        stderr: response.stderr || '',
         exit_code: response.exit_code,
-        # TODO: DaytonaApiClient::SessionExecuteResponse doesn't have additional_properties attribute
         additional_properties: {}
       )
     end
@@ -210,12 +213,8 @@ module Daytona
     #   puts "Command stdout: #{logs.stdout}"
     #   puts "Command stderr: #{logs.stderr}"
     def get_session_command_logs(session_id:, command_id:)
-      parse_session_command_logs(
-        toolbox_api.get_session_command_logs(
-          session_id,
-          command_id
-        )
-      )
+      response = toolbox_api.get_session_command_logs(session_id, command_id)
+      SessionCommandLogsResponse.new(output: response.output, stdout: response.stdout, stderr: response.stderr)
     end
 
     # Asynchronously retrieves and processes the logs for a command executed in a session as they become available
@@ -284,7 +283,10 @@ module Daytona
     #   logs = sandbox.process.get_entrypoint_logs()
     #   puts "Command stdout: #{logs.stdout}"
     #   puts "Command stderr: #{logs.stderr}"
-    def get_entrypoint_logs = parse_session_command_logs(toolbox_api.get_entrypoint_logs)
+    def get_entrypoint_logs
+      response = toolbox_api.get_entrypoint_logs
+      SessionCommandLogsResponse.new(output: response.output, stdout: response.stdout, stderr: response.stderr)
+    end
 
     # Asynchronously retrieves and processes the sandbox entrypoint logs as they become available
     #
@@ -542,64 +544,7 @@ module Daytona
     # @return [Daytona::OtelState, nil]
     attr_reader :otel_state
 
-    # Parse the output of a command to extract ExecutionArtifacts
-    #
-    # @param lines [Array<String>] A list of lines of output from a command
-    # @return [Daytona::ExecutionArtifacts] The artifacts from the command execution
-    def parse_output(lines)
-      artifacts = ExecutionArtifacts.new('', [])
-      stdout_lines = []
-
-      lines.each do |line|
-        if line.start_with?(ARTIFACT_PREFIX)
-          parse_json_line(line:, artifacts:)
-        else
-          stdout_lines << line
-        end
-      end
-
-      artifacts.stdout = stdout_lines.join("\n")
-      artifacts
-    end
-
-    # Parse a JSON line to extract artifacts
-    #
-    # @param line [String] The line to parse
-    # @param artifacts [Daytona::ExecutionArtifacts] The artifacts to add to
-    # @return [void]
-    def parse_json_line(line:, artifacts:)
-      data = JSON.parse(line.sub(ARTIFACT_PREFIX, '').strip, symbolize_names: true)
-
-      case data.fetch(:type, nil)
-      when ArtifactType::CHART
-        artifacts.charts.append(Charts.parse(data.fetch(:value, {})))
-      end
-    end
-
-    # Parse combined stdout/stderr output into separate streams
-    #
-    # @param data [String] Combined log string with STDOUT_PREFIX and STDERR_PREFIX markers
-    # @return [SessionCommandLogsResponse] Response with separated stdout and stderr
-    def parse_session_command_logs(data)
-      stdout, stderr = Util.demux(data)
-
-      SessionCommandLogsResponse.new(
-        output: data,
-        stdout:,
-        stderr:
-      )
-    end
-
-    ARTIFACT_PREFIX = 'dtn_artifact_k39fd2:'
-    private_constant :ARTIFACT_PREFIX
-
     WS_PORT = 2280
     private_constant :WS_PORT
-
-    module ArtifactType
-      ALL = [
-        CHART = 'chart'
-      ].freeze
-    end
   end
 end

data/lib/daytona/sandbox.rb

@@ -90,9 +90,6 @@ module Daytona
     # @return [String] The version of the daemon running in the sandbox
     attr_reader :daemon_version
 
-    # @return [Daytona::SandboxPythonCodeToolbox, Daytona::SandboxTsCodeToolbox]
-    attr_reader :code_toolbox
-
     # @return [Daytona::Config]
     attr_reader :config
 
@@ -114,14 +111,12 @@ module Daytona
     # @return [Daytona::CodeInterpreter]
     attr_reader :code_interpreter
 
-    # @params code_toolbox [Daytona::SandboxPythonCodeToolbox, Daytona::SandboxTsCodeToolbox]
     # @params config [Daytona::Config]
     # @params sandbox_api [DaytonaApiClient::SandboxApi]
     # @params sandbox_dto [DaytonaApiClient::Sandbox]
     # @params otel_state [Daytona::OtelState, nil]
-    def initialize(code_toolbox:, sandbox_dto:, config:, sandbox_api:, otel_state: nil) # rubocop:disable Metrics/MethodLength
+    def initialize(sandbox_dto:, config:, sandbox_api:, otel_state: nil) # rubocop:disable Metrics/MethodLength
       process_response(sandbox_dto)
-      @code_toolbox = code_toolbox
       @config = config
       @sandbox_api = sandbox_api
       @otel_state = otel_state
@@ -150,9 +145,9 @@ module Daytona
 
       @process = Process.new(
         sandbox_id: id,
-        code_toolbox:,
         toolbox_api: process_api,
         get_preview_link: proc { |port| preview_url(port) },
+        language: (labels || {}).fetch(CODE_TOOLBOX_LANGUAGE_LABEL, 'python'),
         otel_state:
       )
       @fs = FileSystem.new(sandbox_id: id, toolbox_api: fs_api, otel_state:)

data/lib/daytona/sdk/version.rb

@@ -2,6 +2,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.163.0'
+    VERSION = '0.164.0.alpha.1'
   end
 end

data/lib/daytona/sdk.rb

@@ -24,9 +24,6 @@ require_relative 'common/response'
 require_relative 'common/snapshot'
 require_relative 'code_interpreter'
 require_relative 'computer_use'
-require_relative 'code_toolbox/sandbox_python_code_toolbox'
-require_relative 'code_toolbox/sandbox_ts_code_toolbox'
-require_relative 'code_toolbox/sandbox_js_code_toolbox'
 require_relative 'daytona'
 require_relative 'file_system'
 require_relative 'git'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.163.0
+  version: 0.164.0.alpha.1
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.163.0
+        version: 0.164.0.alpha.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.163.0
+        version: 0.164.0.alpha.1
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.163.0
+        version: 0.164.0.alpha.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.163.0
+        version: 0.164.0.alpha.1
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -179,9 +179,6 @@ files:
 - Rakefile
 - lib/daytona.rb
 - lib/daytona/code_interpreter.rb
-- lib/daytona/code_toolbox/sandbox_js_code_toolbox.rb
-- lib/daytona/code_toolbox/sandbox_python_code_toolbox.rb
-- lib/daytona/code_toolbox/sandbox_ts_code_toolbox.rb
 - lib/daytona/common/charts.rb
 - lib/daytona/common/code_interpreter.rb
 - lib/daytona/common/code_language.rb

data/lib/daytona/code_toolbox/sandbox_js_code_toolbox.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module Daytona
-  class SandboxJsCodeToolbox
-    def get_run_command(code, params = nil)
-      # Prepend argv fix: node - places '-' at argv[1]; splice it out to match legacy node -e behaviour
-      # Encode the provided code in base64
-      base64_code = Base64.strict_encode64("process.argv.splice(1, 1);\n" + code)
-
-      # Build command-line arguments string
-      argv = ''
-      argv = params.argv.join(' ') if params&.argv && !params.argv.empty?
-
-      # Pipe the base64-encoded code via stdin to avoid OS ARG_MAX limits on large payloads
-      # Use node - to read from stdin (node /dev/stdin does not work when stdin is a pipe)
-      "printf '%s' '#{base64_code}' | base64 -d | node - #{argv}"
-    end
-  end
-end

data/lib/daytona/code_toolbox/sandbox_python_code_toolbox.rb

@@ -1,438 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module Daytona
-  class SandboxPythonCodeToolbox # rubocop:disable Metrics/ClassLength
-    # Get the run command for executing Python code
-    #
-    # @param code [String] The Python code to execute
-    # @param params [Daytona::CodeRunParams, nil] Optional parameters for code execution
-    # @return [String] The command to run the Python code
-    def get_run_command(code, params = nil)
-      encoded_code = Base64.strict_encode64(code)
-
-      # Override plt.show() method if matplotlib is imported
-      if matplotlib_imported?(code)
-        encoded_code = Base64.strict_encode64(
-          Base64.decode64(PYTHON_CODE_WRAPPER).gsub('{encoded_code}', encoded_code)
-        )
-      end
-
-      argv = params&.argv&.join(' ') || ''
-
-      # Pipe the base64-encoded code via stdin to avoid OS ARG_MAX limits on large payloads
-      # printf is a shell builtin that does not invoke execve(), so the base64 string bypasses the kernel ARG_MAX limit
-      # Use -u flag to ensure unbuffered output for real-time error reporting
-      "printf '%s' '#{encoded_code}' | base64 -d | python3 -u - #{argv}"
-    end
-
-    private
-
-    # Check if matplotlib is imported in the code
-    #
-    # @param code [String] The Python code to check
-    # @return [Boolean] True if matplotlib is imported, false otherwise
-    def matplotlib_imported?(code) = PATTERNS.any? { |pattern| code.match?(pattern) }
-
-    PATTERNS = [
-      # Standard imports
-      /^[^#]*import\s+matplotlib/m,
-      /^[^#]*from\s+matplotlib/m,
-      # Dynamic imports
-      /^[^#]*__import__\s*\(\s*['"]matplotlib['"]/m,
-      /^[^#]*importlib\.import_module\s*\(\s*['"]matplotlib['"]/m,
-      # Other dynamic loading patterns
-      /^[^#]*loader\.load_module\s*\(\s*['"]matplotlib['"]/m,
-      /^[^#]*sys\.modules\[['"]matplotlib['"]\]/m
-    ].freeze
-    private_constant :PATTERNS
-
-    PYTHON_CODE_WRAPPER = <<~BASE64.strip
-      aW1wb3J0IGJhc2U2NAppbXBvcnQgZGF0ZXRpbWUKaW1wb3J0IGhhc2hsaWIK
-      aW1wb3J0IGlvCmltcG9ydCBqc29uCmltcG9ydCBsaW5lY2FjaGUKaW1wb3J0
-      IHN5cwppbXBvcnQgdHJhY2ViYWNrCmltcG9ydCB0eXBlcwpmcm9tIGltcG9y
-      dGxpYi5hYmMgaW1wb3J0IExvYWRlciwgTWV0YVBhdGhGaW5kZXIKZnJvbSBp
-      bXBvcnRsaWIudXRpbCBpbXBvcnQgZmluZF9zcGVjLCBzcGVjX2Zyb21fbG9h
-      ZGVyCgojIEdsb2JhbCB2YXJpYWJsZXMgdG8gaG9sZCBpbXBvcnRlZCBsaWJy
-      YXJpZXMgaWYgbmVlZGVkCm5wID0gTm9uZQptcGwgPSBOb25lCnBpbF9pbWcg
-      PSBOb25lCgoKcGx0X3BhdGNoZWQgPSBGYWxzZQpwcm9jZXNzZWRfZmlndXJl
-      cyA9IHNldCgpCgoKZGVmIF9wYXJzZV9wb2ludChwb2ludCk6CiAgICBpZiBp
-      c2luc3RhbmNlKHBvaW50LCBkYXRldGltZS5kYXRlKToKICAgICAgICByZXR1
-      cm4gcG9pbnQuaXNvZm9ybWF0KCkKICAgIGlmIGlzaW5zdGFuY2UocG9pbnQs
-      IG5wLmRhdGV0aW1lNjQpOgogICAgICAgIHJldHVybiBwb2ludC5hc3R5cGUo
-      ImRhdGV0aW1lNjRbc10iKS5hc3R5cGUoc3RyKQogICAgcmV0dXJuIHBvaW50
-      CgoKZGVmIF9pc19ncmlkX2xpbmUobGluZTogYW55KSAtPiBib29sOgogICAg
-      eF9kYXRhID0gbGluZS5nZXRfeGRhdGEoKQogICAgaWYgbGVuKHhfZGF0YSkg
-      IT0gMjoKICAgICAgICByZXR1cm4gRmFsc2UKCiAgICB5X2RhdGEgPSBsaW5l
-      LmdldF95ZGF0YSgpCiAgICBpZiBsZW4oeV9kYXRhKSAhPSAyOgogICAgICAg
-      IHJldHVybiBGYWxzZQoKICAgIGlmIHhfZGF0YVswXSA9PSB4X2RhdGFbMV0g
-      b3IgeV9kYXRhWzBdID09IHlfZGF0YVsxXToKICAgICAgICByZXR1cm4gVHJ1
-      ZQoKICAgIHJldHVybiBGYWxzZQoKCmRlZiBfZXh0cmFjdF9saW5lX2NoYXJ0
-      X2VsZW1lbnRzKGF4KToKICAgIGVsZW1lbnRzID0gW10KCiAgICBmb3IgbGlu
-      ZSBpbiBheC5nZXRfbGluZXMoKToKICAgICAgICBpZiBfaXNfZ3JpZF9saW5l
-      KGxpbmUpOgogICAgICAgICAgICBjb250aW51ZQogICAgICAgIGxhYmVsID0g
-      bGluZS5nZXRfbGFiZWwoKQogICAgICAgIHBvaW50cyA9IFtfcGFyc2VfcG9p
-      bnQoKHgsIHkpKSBmb3IgeCwgeSBpbiB6aXAobGluZS5nZXRfeGRhdGEoKSwg
-      bGluZS5nZXRfeWRhdGEoKSldCgogICAgICAgIGVsZW1lbnQgPSB7ImxhYmVs
-      IjogbGFiZWwsICJwb2ludHMiOiBwb2ludHN9CiAgICAgICAgZWxlbWVudHMu
-      YXBwZW5kKGVsZW1lbnQpCgogICAgcmV0dXJuIGVsZW1lbnRzCgoKZGVmIF9l
-      eHRyYWN0X3NjYXR0ZXJfY2hhcnRfZWxlbWVudHMoYXgpOgogICAgZWxlbWVu
-      dHMgPSBbXQoKICAgIGZvciBjb2xsZWN0aW9uIGluIGF4LmNvbGxlY3Rpb25z
-      OgogICAgICAgIHBvaW50cyA9IFtfcGFyc2VfcG9pbnQoKHgsIHkpKSBmb3Ig
-      eCwgeSBpbiBjb2xsZWN0aW9uLmdldF9vZmZzZXRzKCldCiAgICAgICAgZWxl
-      bWVudCA9IHsibGFiZWwiOiBjb2xsZWN0aW9uLmdldF9sYWJlbCgpLCAicG9p
-      bnRzIjogcG9pbnRzfQogICAgICAgIGVsZW1lbnRzLmFwcGVuZChlbGVtZW50
-      KQoKICAgIHJldHVybiBlbGVtZW50cwoKCmRlZiBfZXh0cmFjdF9iYXJfY2hh
-      cnRfZWxlbWVudHMoYXgpOgogICAgZWxlbWVudHMgPSBbXQogICAgY2hhbmdl
-      X29yaWVudGF0aW9uID0gRmFsc2UKCiAgICBmb3IgY29udGFpbmVyIGluIGF4
-      LmNvbnRhaW5lcnM6CiAgICAgICAgaGVpZ2h0cyA9IFtyZWN0LmdldF9oZWln
-      aHQoKSBmb3IgcmVjdCBpbiBjb250YWluZXJdCiAgICAgICAgaWYgYWxsKGhl
-      aWdodCA9PSBoZWlnaHRzWzBdIGZvciBoZWlnaHQgaW4gaGVpZ2h0cyk6CiAg
-      ICAgICAgICAgICMgdmVydGljYWwgYmFycwogICAgICAgICAgICBjaGFuZ2Vf
-      b3JpZW50YXRpb24gPSBUcnVlCiAgICAgICAgICAgIGxhYmVscyA9IFtsYWJl
-      bC5nZXRfdGV4dCgpIGZvciBsYWJlbCBpbiBheC5nZXRfeXRpY2tsYWJlbHMo
-      KV0KICAgICAgICAgICAgdmFsdWVzID0gW3JlY3QuZ2V0X3dpZHRoKCkgZm9y
-      IHJlY3QgaW4gY29udGFpbmVyXQogICAgICAgIGVsc2U6CiAgICAgICAgICAg
-      ICMgaG9yaXpvbnRhbCBiYXJzCiAgICAgICAgICAgIGxhYmVscyA9IFtsYWJl
-      bC5nZXRfdGV4dCgpIGZvciBsYWJlbCBpbiBheC5nZXRfeHRpY2tsYWJlbHMo
-      KV0KICAgICAgICAgICAgdmFsdWVzID0gaGVpZ2h0cwogICAgICAgIGZvciBs
-      YWJlbCwgdmFsdWUgaW4gemlwKGxhYmVscywgdmFsdWVzKToKICAgICAgICAg
-      ICAgZWxlbWVudCA9IHsibGFiZWwiOiBsYWJlbCwgImdyb3VwIjogY29udGFp
-      bmVyLmdldF9sYWJlbCgpLCAidmFsdWUiOiB2YWx1ZX0KICAgICAgICAgICAg
-      ZWxlbWVudHMuYXBwZW5kKGVsZW1lbnQpCgogICAgcmV0dXJuIGVsZW1lbnRz
-      LCBjaGFuZ2Vfb3JpZW50YXRpb24KCgpkZWYgX2V4dHJhY3RfcGllX2NoYXJ0
-      X2VsZW1lbnRzKGF4KToKICAgIGVsZW1lbnRzID0gW10KCiAgICB3ZWRnZXMg
-      PSBbcGF0Y2ggZm9yIHBhdGNoIGluIGF4LnBhdGNoZXMgaWYgaXNpbnN0YW5j
-      ZShwYXRjaCwgbXBsLnBhdGNoZXMuV2VkZ2UpXQogICAgaWYgbGVuKHdlZGdl
-      cykgPT0gMDoKICAgICAgICByZXR1cm4gZWxlbWVudHMKCiAgICB0ZXh0cyA9
-      IFt0ZXh0X29iai5nZXRfdGV4dCgpIGZvciB0ZXh0X29iaiBpbiBheC50ZXh0
-      c10KCiAgICBsYWJlbHMgPSBbXQogICAgYXV0b3BjdHMgPSBbXQoKICAgIGlm
-      IGxlbih0ZXh0cykgPT0gMiAqIGxlbih3ZWRnZXMpOgogICAgICAgIGxhYmVs
-      cyA9IFt0ZXh0c1tpXSBmb3IgaSBpbiByYW5nZSgwLCAyICogbGVuKHdlZGdl
-      cyksIDIpXQogICAgICAgIGF1dG9wY3RzID0gW3RleHRzW2ldIGZvciBpIGlu
-      IHJhbmdlKDEsIDIgKiBsZW4od2VkZ2VzKSwgMildCiAgICBlbHNlOgogICAg
-      ICAgIGxhYmVscyA9IHRleHRzWzogbGVuKHdlZGdlcyldCgogICAgZm9yIGlk
-      eCwgd2VkZ2UgaW4gZW51bWVyYXRlKHdlZGdlcyk6CiAgICAgICAgZWxlbWVu
-      dCA9IHsKICAgICAgICAgICAgImxhYmVsIjogbGFiZWxzW2lkeF0sCiAgICAg
-      ICAgICAgICJhbmdsZSI6IGFicyh3ZWRnZS50aGV0YTIgLSB3ZWRnZS50aGV0
-      YTEpLAogICAgICAgICAgICAicmFkaXVzIjogd2VkZ2UuciwKICAgICAgICAg
-      ICAgImF1dG9wY3QiOiBhdXRvcGN0c1tpZHhdIGlmIGF1dG9wY3RzIGFuZCBs
-      ZW4oYXV0b3BjdHMpID4gaWR4IGVsc2UgTm9uZSwKICAgICAgICB9CiAgICAg
-      ICAgZWxlbWVudHMuYXBwZW5kKGVsZW1lbnQpCgogICAgcmV0dXJuIGVsZW1l
-      bnRzCgoKIyBweWxpbnQ6IGRpc2FibGU9dG9vLW1hbnktYnJhbmNoZXMKZGVm
-      IF9leHRyYWN0X2JveF9jaGFydF9lbGVtZW50cyhheCk6CiAgICBjaGFuZ2Vf
-      b3JpZW50YXRpb24gPSBGYWxzZQoKICAgIHh0aWNrbGFiZWxzID0gW2xhYmVs
-      LmdldF90ZXh0KCkgZm9yIGxhYmVsIGluIGF4LmdldF94dGlja2xhYmVscygp
-      XQogICAgYm94ZXMgPSBbXQogICAgZm9yIGxhYmVsLCBib3ggaW4gemlwKHh0
-      aWNrbGFiZWxzLCBheC5wYXRjaGVzKToKICAgICAgICB2ZXJ0aWNlcyA9IGJv
-      eC5nZXRfcGF0aCgpLnZlcnRpY2VzCiAgICAgICAgeF92ZXJ0aWNlcyA9IGxp
-      c3QodmVydGljZXNbOiwgMF0pCiAgICAgICAgeV92ZXJ0aWNlcyA9IGxpc3Qo
-      dmVydGljZXNbOiwgMV0pCiAgICAgICAgeCA9IG1pbih4X3ZlcnRpY2VzKQog
-      ICAgICAgIHkgPSBtaW4oeV92ZXJ0aWNlcykKCiAgICAgICAgYm94ZXMuYXBw
-      ZW5kKAogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAieCI6IHgsCiAg
-      ICAgICAgICAgICAgICAieSI6IHksCiAgICAgICAgICAgICAgICAibGFiZWwi
-      OiBsYWJlbCwKICAgICAgICAgICAgICAgICJ3aWR0aCI6IG1heCh4X3ZlcnRp
-      Y2VzKSAtIHgsCiAgICAgICAgICAgICAgICAiaGVpZ2h0IjogbWF4KHlfdmVy
-      dGljZXMpIC0geSwKICAgICAgICAgICAgICAgICJvdXRsaWVycyI6IFtdLAog
-      ICAgICAgICAgICB9CiAgICAgICAgKQoKICAgIG9yaWVudGF0aW9uID0gImhv
-      cml6b250YWwiCiAgICBpZiBhbGwoYm94WyJoZWlnaHQiXSA9PSBib3hlc1sw
-      XVsiaGVpZ2h0Il0gZm9yIGJveCBpbiBib3hlcyk6CiAgICAgICAgb3JpZW50
-      YXRpb24gPSAidmVydGljYWwiCgogICAgaWYgb3JpZW50YXRpb24gPT0gInZl
-      cnRpY2FsIjoKICAgICAgICBjaGFuZ2Vfb3JpZW50YXRpb24gPSBUcnVlCiAg
-      ICAgICAgZm9yIGJveCBpbiBib3hlczoKICAgICAgICAgICAgYm94WyJ4Il0s
-      IGJveFsieSJdID0gYm94WyJ5Il0sIGJveFsieCJdCiAgICAgICAgICAgIGJv
-      eFsid2lkdGgiXSwgYm94WyJoZWlnaHQiXSA9IGJveFsiaGVpZ2h0Il0sIGJv
-      eFsid2lkdGgiXQoKICAgIGZvciBsaW5lIGluIGF4LmxpbmVzOgogICAgICAg
-      IHhkYXRhID0gbGluZS5nZXRfeGRhdGEoKQogICAgICAgIHlkYXRhID0gbGlu
-      ZS5nZXRfeWRhdGEoKQoKICAgICAgICBpZiBvcmllbnRhdGlvbiA9PSAidmVy
-      dGljYWwiOgogICAgICAgICAgICB4ZGF0YSwgeWRhdGEgPSB5ZGF0YSwgeGRh
-      dGEKCiAgICAgICAgaWYgbGVuKHhkYXRhKSA8PSAxIG9yIGxlbih5ZGF0YSkg
-      IT0gMjoKICAgICAgICAgICAgY29udGludWUKCiAgICAgICAgZm9yIGJveCBp
-      biBib3hlczoKICAgICAgICAgICAgaWYgYm94WyJ4Il0gPD0geGRhdGFbMF0g
-      PD0geGRhdGFbMV0gPD0gYm94WyJ4Il0gKyBib3hbIndpZHRoIl06CiAgICAg
-      ICAgICAgICAgICAjIEhvcml6b250YWwgbGluZSAobWVkaWFuIG9yIGNhcCkK
-      ICAgICAgICAgICAgICAgIGlmIGFicyh5ZGF0YVswXSAtIHlkYXRhWzFdKSA8
-      IDAuMDAxIGFuZCBib3hbInkiXSA8PSB5ZGF0YVswXSA8PSBib3hbInkiXSAr
-      IGJveFsiaGVpZ2h0Il06CiAgICAgICAgICAgICAgICAgICAgYm94WyJtZWRp
-      YW4iXSA9IHlkYXRhWzBdCiAgICAgICAgICAgICAgICAjIFZlcnRpY2FsIGxp
-      bmUgKHdoaXNrZXJzKQogICAgICAgICAgICAgICAgZWxpZiBhYnMoeGRhdGFb
-      MF0gLSB4ZGF0YVsxXSkgPCAwLjAwMToKICAgICAgICAgICAgICAgICAgICB5
-      X21pbiA9IG1pbih5ZGF0YSkKICAgICAgICAgICAgICAgICAgICB5X21heCA9
-      IG1heCh5ZGF0YSkKCiAgICAgICAgICAgICAgICAgICAgIyBJZiBhdHRhY2hl
-      ZCB0byBib3R0b20gb2YgYm94CiAgICAgICAgICAgICAgICAgICAgaWYgYWJz
-      KHlfbWF4IC0gYm94WyJ5Il0pIDwgMC4wMDE6CiAgICAgICAgICAgICAgICAg
-      ICAgICAgIGJveFsid2hpc2tlcl9sb3dlciJdID0geV9taW4KCiAgICAgICAg
-      ICAgICAgICAgICAgIyBJZiBhdHRhY2hlZCB0byB0b3Agb2YgYm94CiAgICAg
-      ICAgICAgICAgICAgICAgZWxpZiBhYnMoeV9taW4gLSAoYm94WyJ5Il0gKyBi
-      b3hbImhlaWdodCJdKSkgPCAwLjAwMToKICAgICAgICAgICAgICAgICAgICAg
-      ICAgYm94WyJ3aGlza2VyX3VwcGVyIl0gPSB5X21heAogICAgICAgICAgICAg
-      ICAgYnJlYWsKCiAgICBvdXRsaWVyX2NhbmRpZGF0ZXMgPSBbXQoKICAgICMg
-      Q2hlY2sgZm9yIGFueSBtYXJrZXJzIGluIGFsbCBhcnRpc3RzCiAgICBmb3Ig
-      YXJ0aXN0IGluIGF4LmdldF9jaGlsZHJlbigpOgogICAgICAgIGlmIGhhc2F0
-      dHIoYXJ0aXN0LCAiZ2V0X3hkYXRhIikgYW5kIGhhc2F0dHIoYXJ0aXN0LCAi
-      Z2V0X3lkYXRhIik6CiAgICAgICAgICAgIHRyeToKICAgICAgICAgICAgICAg
-      IHhkYXRhID0gYXJ0aXN0LmdldF94ZGF0YSgpCiAgICAgICAgICAgICAgICB5
-      ZGF0YSA9IGFydGlzdC5nZXRfeWRhdGEoKQoKICAgICAgICAgICAgICAgIGlm
-      IG9yaWVudGF0aW9uID09ICJ2ZXJ0aWNhbCI6CiAgICAgICAgICAgICAgICAg
-      ICAgeGRhdGEsIHlkYXRhID0geWRhdGEsIHhkYXRhCgogICAgICAgICAgICAg
-      ICAgaWYgaXNpbnN0YW5jZSh4ZGF0YSwgKGxpc3QsIG5wLm5kYXJyYXkpKSBh
-      bmQgaXNpbnN0YW5jZSh5ZGF0YSwgKGxpc3QsIG5wLm5kYXJyYXkpKToKICAg
-      ICAgICAgICAgICAgICAgICBmb3IgaSBpbiByYW5nZShtaW4obGVuKHhkYXRh
-      KSwgbGVuKHlkYXRhKSkpOgogICAgICAgICAgICAgICAgICAgICAgICBvdXRs
-      aWVyX2NhbmRpZGF0ZXMuYXBwZW5kKChmbG9hdCh4ZGF0YVtpXSksIGZsb2F0
-      KHlkYXRhW2ldKSkpCiAgICAgICAgICAgIGV4Y2VwdDoKICAgICAgICAgICAg
-      ICAgIHBhc3MKCiAgICAjIEFzc2lnbiBwb2ludHMgdG8gYm94ZXMgYW5kIGRl
-      dGVybWluZSBpZiB0aGV5J3JlIG91dGxpZXJzCiAgICBmb3IgeCwgeSBpbiBv
-      dXRsaWVyX2NhbmRpZGF0ZXM6CiAgICAgICAgZm9yIGJveCBpbiBib3hlczoK
-      ICAgICAgICAgICAgaWYgYm94WyJ4Il0gPD0geCA8PSBib3hbIngiXSArIGJv
-      eFsid2lkdGgiXToKICAgICAgICAgICAgICAgIGJveF9jZW50ZXIgPSBib3hb
-      IngiXSArIGJveFsid2lkdGgiXSAvIDIKICAgICAgICAgICAgICAgIGlmIGFi
-      cyh4IC0gYm94X2NlbnRlcikgPCAwLjAwMToKICAgICAgICAgICAgICAgICAg
-      ICB5X21pbiA9IGJveFsieSJdCiAgICAgICAgICAgICAgICAgICAgeV9tYXgg
-      PSBib3hbInkiXSArIGJveFsiaGVpZ2h0Il0KICAgICAgICAgICAgICAgICAg
-      ICBpZiBib3guZ2V0KCJ3aGlza2VyX2xvd2VyIiwgTm9uZSk6CiAgICAgICAg
-      ICAgICAgICAgICAgICAgIHlfbWluID0gYm94WyJ3aGlza2VyX2xvd2VyIl0K
-      ICAgICAgICAgICAgICAgICAgICBpZiBib3guZ2V0KCJ3aGlza2VyX3VwcGVy
-      IiwgTm9uZSk6CiAgICAgICAgICAgICAgICAgICAgICAgIHlfbWF4ID0gYm94
-      WyJ3aGlza2VyX3VwcGVyIl0KICAgICAgICAgICAgICAgICAgICBpZiB5IDwg
-      eV9taW4gb3IgeSA+IHlfbWF4OgogICAgICAgICAgICAgICAgICAgICAgICBi
-      b3hbIm91dGxpZXJzIl0uYXBwZW5kKHkpCiAgICAgICAgICAgICAgICBicmVh
-      awoKICAgIHJldHVybiBbCiAgICAgICAgewogICAgICAgICAgICAibGFiZWwi
-      OiBib3hbImxhYmVsIl0sCiAgICAgICAgICAgICJtaW4iOiBib3guZ2V0KCJ3
-      aGlza2VyX2xvd2VyIiwgTm9uZSksCiAgICAgICAgICAgICJmaXJzdF9xdWFy
-      dGlsZSI6IGJveFsieSJdLAogICAgICAgICAgICAibWVkaWFuIjogYm94Lmdl
-      dCgibWVkaWFuIiwgTm9uZSksCiAgICAgICAgICAgICJ0aGlyZF9xdWFydGls
-      ZSI6IGJveFsieSJdICsgYm94WyJoZWlnaHQiXSwKICAgICAgICAgICAgIm1h
-      eCI6IGJveC5nZXQoIndoaXNrZXJfdXBwZXIiLCBOb25lKSwKICAgICAgICAg
-      ICAgIm91dGxpZXJzIjogYm94WyJvdXRsaWVycyJdLAogICAgICAgIH0KICAg
-      ICAgICBmb3IgYm94IGluIGJveGVzCiAgICBdLCBjaGFuZ2Vfb3JpZW50YXRp
-      b24KCgpkZWYgX3NhdmVfZmlndXJlX2FzX2Jhc2U2NChmaWcsIGJib3hfaW5j
-      aGVzPSJ0aWdodCIsIGRwaT0xMDApOgogICAgIyBGaXJzdCBzYXZlIHdpdGgg
-      bWF0cGxvdGxpYgogICAgcG5nX2J1ZmZlciA9IGlvLkJ5dGVzSU8oKQogICAg
-      ZmlnLnNhdmVmaWcocG5nX2J1ZmZlciwgZm9ybWF0PSJwbmciLCBiYm94X2lu
-      Y2hlcz1iYm94X2luY2hlcywgZHBpPWRwaSkKICAgIHBuZ19idWZmZXIuc2Vl
-      aygwKQoKICAgICMgT3BlbiB3aXRoIFBJTCBhbmQgYXBwbHkgbWF4aW11bSBj
-      b21wcmVzc2lvbgogICAgd2l0aCBwaWxfaW1nLm9wZW4ocG5nX2J1ZmZlcikg
-      YXMgaW1nOgogICAgICAgIG9wdGltaXplZF9idWZmZXIgPSBpby5CeXRlc0lP
-      KCkKICAgICAgICBpbWcuc2F2ZShvcHRpbWl6ZWRfYnVmZmVyLCBmb3JtYXQ9
-      InBuZyIsIG9wdGltaXplPVRydWUsIHF1YWxpdHk9MTAwLCBjb21wcmVzc19s
-      ZXZlbD05KQogICAgICAgIG9wdGltaXplZF9idWZmZXIuc2VlaygwKQogICAg
-      ICAgIHJldHVybiBiYXNlNjQuYjY0ZW5jb2RlKG9wdGltaXplZF9idWZmZXIu
-      Z2V0dmFsdWUoKSkuZGVjb2RlKCJ1dGYtOCIpCgoKZGVmIF9nZXRfZmlndXJl
-      X2hhc2goZmlnKToKICAgIHBuZ19idWZmZXIgPSBpby5CeXRlc0lPKCkKICAg
-      IGZpZy5zYXZlZmlnKHBuZ19idWZmZXIsIGZvcm1hdD0icG5nIiwgZHBpPTUw
-      KQogICAgcmV0dXJuIGhhc2hsaWIubWQ1KHBuZ19idWZmZXIuZ2V0dmFsdWUo
-      KSkuaGV4ZGlnZXN0KCkKCgpkZWYgX2dldF9jaGFydF90eXBlKGF4KToKICAg
-      IG9iamVjdHMgPSBsaXN0KAogICAgICAgIGZpbHRlcigKICAgICAgICAgICAg
-      bGFtYmRhIG9iajogbm90IGlzaW5zdGFuY2Uob2JqLCBtcGwudGV4dC5UZXh0
-      KSBhbmQgbm90IGlzaW5zdGFuY2Uob2JqLCBtcGwucGF0Y2hlcy5TaGFkb3cp
-      LAogICAgICAgICAgICBheC5fY2hpbGRyZW4sICAjIHB5bGludDogZGlzYWJs
-      ZT1wcm90ZWN0ZWQtYWNjZXNzCiAgICAgICAgKQogICAgKQoKICAgICMgQ2hl
-      Y2sgZm9yIExpbmUgcGxvdHMKICAgIGlmIGFsbChpc2luc3RhbmNlKGxpbmUs
-      IG1wbC5saW5lcy5MaW5lMkQpIGZvciBsaW5lIGluIG9iamVjdHMpOgogICAg
-      ICAgIHJldHVybiAibGluZSIKCiAgICBpZiBhbGwoaXNpbnN0YW5jZShib3hf
-      b3JfcGF0aCwgKG1wbC5wYXRjaGVzLlBhdGhQYXRjaCwgbXBsLmxpbmVzLkxp
-      bmUyRCkpIGZvciBib3hfb3JfcGF0aCBpbiBvYmplY3RzKToKICAgICAgICBy
-      ZXR1cm4gImJveF9hbmRfd2hpc2tlciIKCiAgICBmaWx0ZXJlZCA9IFtdCiAg
-      ICBmb3Igb2JqIGluIG9iamVjdHM6CiAgICAgICAgaWYgaXNpbnN0YW5jZShv
-      YmosIG1wbC5saW5lcy5MaW5lMkQpIGFuZCBfaXNfZ3JpZF9saW5lKG9iaik6
-      CiAgICAgICAgICAgIGNvbnRpbnVlCiAgICAgICAgZmlsdGVyZWQuYXBwZW5k
-      KG9iaikKCiAgICBvYmplY3RzID0gZmlsdGVyZWQKCiAgICAjIENoZWNrIGZv
-      ciBTY2F0dGVyIHBsb3RzCiAgICBpZiBhbGwoaXNpbnN0YW5jZShwYXRoLCBt
-      cGwuY29sbGVjdGlvbnMuUGF0aENvbGxlY3Rpb24pIGZvciBwYXRoIGluIG9i
-      amVjdHMpOgogICAgICAgIHJldHVybiAic2NhdHRlciIKCiAgICAjIENoZWNr
-      IGZvciBCYXIgcGxvdHMKICAgIGlmIGFsbChpc2luc3RhbmNlKHJlY3QsIG1w
-      bC5wYXRjaGVzLlJlY3RhbmdsZSkgZm9yIHJlY3QgaW4gb2JqZWN0cyk6CiAg
-      ICAgICAgcmV0dXJuICJiYXIiCgogICAgIyBDaGVjayBmb3IgUGllIHBsb3Rz
-      CiAgICBpZiBhbGwoaXNpbnN0YW5jZShhcnRpc3QsIG1wbC5wYXRjaGVzLldl
-      ZGdlKSBmb3IgYXJ0aXN0IGluIG9iamVjdHMpOgogICAgICAgIHJldHVybiAi
-      cGllIgoKICAgIHJldHVybiAidW5rbm93biIKCgpkZWYgX2lzX2F1dG9fZW1w
-      dHlfYXhpcyhheCk6CiAgICByZXR1cm4gYXguZ2V0X3N1YnBsb3RzcGVjKCkg
-      aXMgbm90IE5vbmUgYW5kIG5vdCBheC5oYXNfZGF0YSgpCgoKZGVmIF9pc19j
-      b2xvcmJhcl9heGlzKGF4KToKICAgIHJldHVybiBhbnkoCiAgICAgICAgIyBw
-      eWxpbnQ6IGRpc2FibGU9cHJvdGVjdGVkLWFjY2VzcwogICAgICAgIGlzaW5z
-      dGFuY2UoY2hpbGQsIG1wbC5jb2xvcmJhci5fQ29sb3JiYXJTcGluZSkKICAg
-      ICAgICBmb3IgY2hpbGQgaW4gYXguZ2V0X2NoaWxkcmVuKCkKICAgICkKCgpk
-      ZWYgX2ZpbHRlcl9vdXRfdW53YW50ZWRfYXhlcyhheGVzKToKICAgIHJldHVy
-      biBbYXggZm9yIGF4IGluIGF4ZXMgaWYgbm90IF9pc19hdXRvX2VtcHR5X2F4
-      aXMoYXgpIGFuZCBub3QgX2lzX2NvbG9yYmFyX2F4aXMoYXgpXQoKCmRlZiBf
-      ZXh0cmFjdF90aWNrc19kYXRhKGNvbnZlcnRlcjogYW55LCB0aWNrczogYW55
-      KSAtPiBsaXN0OgogICAgaWYgaXNpbnN0YW5jZShjb252ZXJ0ZXIsIG1wbC5k
-      YXRlcy5fU3dpdGNoYWJsZURhdGVDb252ZXJ0ZXIpOiAgIyBweWxpbnQ6IGRp
-      c2FibGU9cHJvdGVjdGVkLWFjY2VzcwogICAgICAgIHJldHVybiBbbXBsLmRh
-      dGVzLm51bTJkYXRlKHRpY2spLmlzb2Zvcm1hdCgpIGZvciB0aWNrIGluIHRp
-      Y2tzXQogICAgdHJ5OgogICAgICAgIHJldHVybiBbZmxvYXQodGljaykgZm9y
-      IHRpY2sgaW4gdGlja3NdCiAgICBleGNlcHQgRXhjZXB0aW9uOgogICAgICAg
-      IHJldHVybiBsaXN0KHRpY2tzKQoKCmRlZiBfZXh0cmFjdF9zY2FsZShjb252
-      ZXJ0ZXIsIHNjYWxlOiBzdHIsIHRpY2tzLCBsYWJlbHMpIC0+IHN0cjoKICAg
-      IGlmIGlzaW5zdGFuY2UoY29udmVydGVyLCBtcGwuZGF0ZXMuX1N3aXRjaGFi
-      bGVEYXRlQ29udmVydGVyKTogICMgcHlsaW50OiBkaXNhYmxlPXByb3RlY3Rl
-      ZC1hY2Nlc3MKICAgICAgICByZXR1cm4gImRhdGV0aW1lIgoKICAgICMgSWYg
-      dGhlIHNjYWxlIGlzIG5vdCBsaW5lYXIsIGl0IGNhbid0IGJlIGNhdGVnb3Jp
-      Y2FsCiAgICBpZiBzY2FsZSAhPSAibGluZWFyIjoKICAgICAgICByZXR1cm4g
-      c2NhbGUKCiAgICAjIElmIGFsbCB0aGUgdGlja3MgYXJlIGludGVnZXJzIGFu
-      ZCBhcmUgaW4gb3JkZXIgZnJvbSAwIHRvIG4tMQogICAgIyBhbmQgdGhlIGxh
-      YmVscyBhcmVuJ3QgY29ycmVzcG9uZGluZyB0byB0aGUgdGlja3MsIGl0J3Mg
-      Y2F0ZWdvcmljYWwKICAgIGZvciBpLCB0aWNrX2FuZF9sYWJlbCBpbiBlbnVt
-      ZXJhdGUoemlwKHRpY2tzLCBsYWJlbHMpKToKICAgICAgICB0aWNrLCBsYWJl
-      bCA9IHRpY2tfYW5kX2xhYmVsCiAgICAgICAgaWYgaXNpbnN0YW5jZSh0aWNr
-      LCAoaW50LCBmbG9hdCkpIGFuZCB0aWNrID09IGkgYW5kIHN0cihpKSAhPSBs
-      YWJlbDoKICAgICAgICAgICAgY29udGludWUKICAgICAgICAjIEZvdW5kIGEg
-      dGljaywgd2hpY2ggd291bGRuJ3QgYmUgaW4gYSBjYXRlZ29yaWNhbCBzY2Fs
-      ZQogICAgICAgIHJldHVybiAibGluZWFyIgoKICAgIHJldHVybiAiY2F0ZWdv
-      cmljYWwiCgoKZGVmIF9leHRyYWN0X2NoYXJ0X2RhdGEoYXgpOgogICAgZGF0
-      YSA9IHt9CgogICAgZGF0YVsidGl0bGUiXSA9IGF4LmdldF90aXRsZSgpCgog
-      ICAgZGF0YVsieF9sYWJlbCJdID0gYXguZ2V0X3hsYWJlbCgpCiAgICBkYXRh
-      WyJ5X2xhYmVsIl0gPSBheC5nZXRfeWxhYmVsKCkKCiAgICB4X3RpY2tfbGFi
-      ZWxzID0gW2xhYmVsLmdldF90ZXh0KCkgZm9yIGxhYmVsIGluIGF4LmdldF94
-      dGlja2xhYmVscygpXQogICAgZGF0YVsieF90aWNrcyJdID0gX2V4dHJhY3Rf
-      dGlja3NfZGF0YShheC54YXhpcy5nZXRfY29udmVydGVyKCksIGF4LmdldF94
-      dGlja3MoKSkKICAgIGRhdGFbInhfdGlja19sYWJlbHMiXSA9IHhfdGlja19s
-      YWJlbHMKICAgIGRhdGFbInhfc2NhbGUiXSA9IF9leHRyYWN0X3NjYWxlKGF4
-      LnhheGlzLmdldF9jb252ZXJ0ZXIoKSwgYXguZ2V0X3hzY2FsZSgpLCBheC5n
-      ZXRfeHRpY2tzKCksIHhfdGlja19sYWJlbHMpCgogICAgeV90aWNrX2xhYmVs
-      cyA9IFtsYWJlbC5nZXRfdGV4dCgpIGZvciBsYWJlbCBpbiBheC5nZXRfeXRp
-      Y2tsYWJlbHMoKV0KICAgIGRhdGFbInlfdGlja3MiXSA9IF9leHRyYWN0X3Rp
-      Y2tzX2RhdGEoYXgueWF4aXMuZ2V0X2NvbnZlcnRlcigpLCBheC5nZXRfeXRp
-      Y2tzKCkpCiAgICBkYXRhWyJ5X3RpY2tfbGFiZWxzIl0gPSB5X3RpY2tfbGFi
-      ZWxzCiAgICBkYXRhWyJ5X3NjYWxlIl0gPSBfZXh0cmFjdF9zY2FsZShheC55
-      YXhpcy5nZXRfY29udmVydGVyKCksIGF4LmdldF95c2NhbGUoKSwgYXguZ2V0
-      X3l0aWNrcygpLCB5X3RpY2tfbGFiZWxzKQoKICAgIGNoYXJ0X3R5cGUgPSBf
-      Z2V0X2NoYXJ0X3R5cGUoYXgpCiAgICBlbGVtZW50cyA9IFtdCiAgICBjaGFu
-      Z2Vfb3JpZW50YXRpb24gPSBGYWxzZQoKICAgIGlmIGNoYXJ0X3R5cGUgPT0g
-      ImxpbmUiOgogICAgICAgIGVsZW1lbnRzID0gX2V4dHJhY3RfbGluZV9jaGFy
-      dF9lbGVtZW50cyhheCkKICAgIGVsaWYgY2hhcnRfdHlwZSA9PSAic2NhdHRl
-      ciI6CiAgICAgICAgZWxlbWVudHMgPSBfZXh0cmFjdF9zY2F0dGVyX2NoYXJ0
-      X2VsZW1lbnRzKGF4KQogICAgZWxpZiBjaGFydF90eXBlID09ICJiYXIiOgog
-      ICAgICAgIGVsZW1lbnRzLCBjaGFuZ2Vfb3JpZW50YXRpb24gPSBfZXh0cmFj
-      dF9iYXJfY2hhcnRfZWxlbWVudHMoYXgpCiAgICBlbGlmIGNoYXJ0X3R5cGUg
-      PT0gImJveF9hbmRfd2hpc2tlciI6CiAgICAgICAgZWxlbWVudHMsIGNoYW5n
-      ZV9vcmllbnRhdGlvbiA9IF9leHRyYWN0X2JveF9jaGFydF9lbGVtZW50cyhh
-      eCkKICAgIGVsaWYgY2hhcnRfdHlwZSA9PSAicGllIjoKICAgICAgICBlbGVt
-      ZW50cyA9IF9leHRyYWN0X3BpZV9jaGFydF9lbGVtZW50cyhheCkKCiAgICBp
-      ZiBjaGFuZ2Vfb3JpZW50YXRpb246CiAgICAgICAgZGF0YVsieF9sYWJlbCJd
-      LCBkYXRhWyJ5X2xhYmVsIl0gPSBkYXRhWyJ5X2xhYmVsIl0sIGRhdGFbInhf
-      bGFiZWwiXQoKICAgIGRhdGFbInR5cGUiXSA9IGNoYXJ0X3R5cGUKICAgIGRh
-      dGFbImVsZW1lbnRzIl0gPSBlbGVtZW50cwoKICAgIHJldHVybiBkYXRhCgoK
-      ZGVmIF9jdXN0b21fanNvbl9zZXJpYWxpemVyKG9iaik6CiAgICBpZiBpc2lu
-      c3RhbmNlKG9iaiwgbnAuaW50ZWdlcik6CiAgICAgICAgcmV0dXJuIGludChv
-      YmopCiAgICBpZiBpc2luc3RhbmNlKG9iaiwgbnAuZmxvYXRpbmcpOgogICAg
-      ICAgIHJldHVybiBmbG9hdChvYmopCiAgICBpZiBpc2luc3RhbmNlKG9iaiwg
-      bnAubmRhcnJheSk6CiAgICAgICAgcmV0dXJuIG9iai50b2xpc3QoKQogICAg
-      aWYgaXNpbnN0YW5jZShvYmosIHNldCk6CiAgICAgICAgcmV0dXJuIGxpc3Qo
-      b2JqKQogICAgcmFpc2UgVHlwZUVycm9yKGYiVHlwZSB7dHlwZShvYmopfSBu
-      b3Qgc2VyaWFsaXphYmxlIikKCgpkZWYgZXh0cmFjdF9hbmRfcHJpbnRfZmln
-      dXJlX21ldGFkYXRhKGZpZyk6CiAgICAiIiJFeHRyYWN0IG1ldGFkYXRhIGZy
-      b20gYSBtYXRwbG90bGliIGZpZ3VyZSBhbmQgcHJpbnQgYXMgSlNPTiIiIgog
-      ICAgbWV0YWRhdGEgPSB7fQogICAgc3VicGxvdHMgPSBbXQoKICAgIGF4ZXMg
-      PSBfZmlsdGVyX291dF91bndhbnRlZF9heGVzKGZpZy5heGVzKQoKICAgIGZv
-      ciBheCBpbiBheGVzOgogICAgICAgIGRhdGEgPSBfZXh0cmFjdF9jaGFydF9k
-      YXRhKGF4KQogICAgICAgIHN1YnBsb3RzLmFwcGVuZChkYXRhKQoKICAgIGlm
-      IGxlbihzdWJwbG90cykgPiAxOgogICAgICAgIG1ldGFkYXRhID0gewogICAg
-      ICAgICAgICAidGl0bGUiOiBmaWcudGV4dHNbMF0uZ2V0X3RleHQoKSBpZiBm
-      aWcudGV4dHMgYW5kIGxlbihmaWcudGV4dHMpID4gMCBlbHNlIE5vbmUsCiAg
-      ICAgICAgICAgICJ0eXBlIjogImNvbXBvc2l0ZV9jaGFydCIsCiAgICAgICAg
-      ICAgICJlbGVtZW50cyI6IHN1YnBsb3RzLAogICAgICAgIH0KICAgIGVsc2U6
-      CiAgICAgICAgbWV0YWRhdGEgPSBzdWJwbG90c1swXSBpZiBzdWJwbG90cyBh
-      bmQgbGVuKHN1YnBsb3RzKSA+IDAgZWxzZSB7InR5cGUiOiAidW5rbm93biJ9
-      CgogICAgbWV0YWRhdGFbInBuZyJdID0gX3NhdmVfZmlndXJlX2FzX2Jhc2U2
-      NChmaWcpCiAgICBqc29uX291dHB1dCA9IHsidHlwZSI6ICJjaGFydCIsICJ2
-      YWx1ZSI6IG1ldGFkYXRhfQoKICAgIHByaW50KGYiZHRuX2FydGlmYWN0X2sz
-      OWZkMjp7anNvbi5kdW1wcyhqc29uX291dHB1dCwgZGVmYXVsdD1fY3VzdG9t
-      X2pzb25fc2VyaWFsaXplcil9IikKCgpjbGFzcyBNYXRwbG90bGliRmluZGVy
-      KE1ldGFQYXRoRmluZGVyKToKICAgICIiIkN1c3RvbSBmaW5kZXIgdG8gaW50
-      ZXJjZXB0IG1hdHBsb3RsaWIucHlwbG90IGltcG9ydHMiIiIKCiAgICBkZWYg
-      ZmluZF9zcGVjKHNlbGYsIGZ1bGxuYW1lLCBwYXRoLCB0YXJnZXQ9Tm9uZSk6
-      ICAjIHB5bGludDogZGlzYWJsZT11bnVzZWQtYXJndW1lbnQKICAgICAgICBn
-      bG9iYWwgcGx0X3BhdGNoZWQsIG5wLCBtcGwsIHBpbF9pbWcgICMgcHlsaW50
-      OiBkaXNhYmxlPWdsb2JhbC1zdGF0ZW1lbnQKICAgICAgICBpZiBmdWxsbmFt
-      ZSA9PSAibWF0cGxvdGxpYi5weXBsb3QiIGFuZCBub3QgcGx0X3BhdGNoZWQ6
-      CiAgICAgICAgICAgIHBsdF9wYXRjaGVkID0gVHJ1ZQoKICAgICAgICAgICAg
-      IyBJbXBvcnQgbnVtcHkgYW5kIG1hdHBsb3RsaWIgb25jZSB3ZSBhcmUgc3Vy
-      ZSB3ZSBuZWVkIHRoZW0KICAgICAgICAgICAgIyBweWxpbnQ6IGRpc2FibGU9
-      aW1wb3J0LW91dHNpZGUtdG9wbGV2ZWwKICAgICAgICAgICAgaW1wb3J0IG1h
-      dHBsb3RsaWIKICAgICAgICAgICAgaW1wb3J0IG51bXB5CiAgICAgICAgICAg
-      IGZyb20gUElMIGltcG9ydCBJbWFnZQoKICAgICAgICAgICAgIyBTdG9yZSB0
-      aGVtIGluIGdsb2JhbCB2YXJpYWJsZXMgZm9yIHVzZSB0aHJvdWdob3V0IHRo
-      ZSBtb2R1bGUKICAgICAgICAgICAgbnAgPSBudW1weQogICAgICAgICAgICBt
-      cGwgPSBtYXRwbG90bGliCiAgICAgICAgICAgIHBpbF9pbWcgPSBJbWFnZQoK
-      ICAgICAgICAgICAgb3JpZ2luYWxfc3BlYyA9IGZpbmRfc3BlYyhmdWxsbmFt
-      ZSkKICAgICAgICAgICAgaWYgb3JpZ2luYWxfc3BlYyBpcyBOb25lOgogICAg
-      ICAgICAgICAgICAgcmV0dXJuIE5vbmUKICAgICAgICAgICAgcmV0dXJuIHNw
-      ZWNfZnJvbV9sb2FkZXIoCiAgICAgICAgICAgICAgICBmdWxsbmFtZSwKICAg
-      ICAgICAgICAgICAgIE1hdHBsb3RsaWJMb2FkZXIob3JpZ2luYWxfc3BlYy5s
-      b2FkZXIpLAogICAgICAgICAgICAgICAgb3JpZ2luPW9yaWdpbmFsX3NwZWMu
-      b3JpZ2luLAogICAgICAgICAgICAgICAgaXNfcGFja2FnZT1vcmlnaW5hbF9z
-      cGVjLnN1Ym1vZHVsZV9zZWFyY2hfbG9jYXRpb25zIGlzIG5vdCBOb25lLAog
-      ICAgICAgICAgICApCiAgICAgICAgcmV0dXJuIE5vbmUKCgpjbGFzcyBNYXRw
-      bG90bGliTG9hZGVyKExvYWRlcik6CiAgICAiIiJDdXN0b20gbG9hZGVyIHRv
-      IHBhdGNoIHRoZSBtYXRwbG90bGliLnB5cGxvdCBtb2R1bGUiIiIKCiAgICBk
-      ZWYgX19pbml0X18oc2VsZiwgb3JpZ2luYWxfbG9hZGVyKToKICAgICAgICBz
-      ZWxmLm9yaWdpbmFsX2xvYWRlciA9IG9yaWdpbmFsX2xvYWRlcgoKICAgIGRl
-      ZiBjcmVhdGVfbW9kdWxlKHNlbGYsIHNwZWMpOgogICAgICAgIHJldHVybiBz
-      ZWxmLm9yaWdpbmFsX2xvYWRlci5jcmVhdGVfbW9kdWxlKHNwZWMpCgogICAg
-      ZGVmIGV4ZWNfbW9kdWxlKHNlbGYsIG1vZHVsZSk6CiAgICAgICAgc2VsZi5v
-      cmlnaW5hbF9sb2FkZXIuZXhlY19tb2R1bGUobW9kdWxlKQogICAgICAgIGlm
-      IGhhc2F0dHIobW9kdWxlLCAic2hvdyIpOgogICAgICAgICAgICBvcmlnaW5h
-      bF9zaG93ID0gbW9kdWxlLnNob3cKCiAgICAgICAgICAgIGRlZiBjdXN0b21f
-      c2hvdygqYXJncywgKiprd2FyZ3MpOgogICAgICAgICAgICAgICAgZ2xvYmFs
-      IHByb2Nlc3NlZF9maWd1cmVzICAjIHB5bGludDogZGlzYWJsZT1nbG9iYWwt
-      dmFyaWFibGUtbm90LWFzc2lnbmVkCiAgICAgICAgICAgICAgICBmaWdfbnVt
-      cyA9IG1vZHVsZS5nZXRfZmlnbnVtcygpCiAgICAgICAgICAgICAgICBmb3Ig
-      ZmlnX251bSBpbiBmaWdfbnVtczoKICAgICAgICAgICAgICAgICAgICBmaWcg
-      PSBtb2R1bGUuZmlndXJlKGZpZ19udW0pCiAgICAgICAgICAgICAgICAgICAg
-      ZmlnX2hhc2ggPSBfZ2V0X2ZpZ3VyZV9oYXNoKGZpZykKICAgICAgICAgICAg
-      ICAgICAgICBpZiBmaWdfaGFzaCBub3QgaW4gcHJvY2Vzc2VkX2ZpZ3VyZXM6
-      CiAgICAgICAgICAgICAgICAgICAgICAgIGV4dHJhY3RfYW5kX3ByaW50X2Zp
-      Z3VyZV9tZXRhZGF0YShmaWcpCiAgICAgICAgICAgICAgICAgICAgICAgIHBy
-      b2Nlc3NlZF9maWd1cmVzLmFkZChmaWdfaGFzaCkKICAgICAgICAgICAgICAg
-      IHJlc3VsdCA9IG9yaWdpbmFsX3Nob3coKmFyZ3MsICoqa3dhcmdzKQogICAg
-      ICAgICAgICAgICAgbW9kdWxlLmNsb3NlKCJhbGwiKQogICAgICAgICAgICAg
-      ICAgcmV0dXJuIHJlc3VsdAoKICAgICAgICAgICAgbW9kdWxlLnNob3cgPSBj
-      dXN0b21fc2hvdwoKCmRlZiBzZXR1cF91c2VyX2NvZGVfZW52aXJvbm1lbnQo
-      Y29kZSk6CiAgICAiIiJTZXQgdXAgdGhlIG1vZHVsZSB0byBydW4gdXNlciBj
-      b2RlIGluIiIiCiAgICBtb2R1bGUgPSB0eXBlcy5Nb2R1bGVUeXBlKCJfX21h
-      aW5fXyIpCiAgICBtb2R1bGUuX19maWxlX18gPSAiPHRhcmdldF9jb2RlPiIK
-      ICAgIHN5cy5tb2R1bGVzWyJfX21haW5fXyJdID0gbW9kdWxlCiAgICBjb2Rl
-      X2xpbmVzID0gY29kZS5zcGxpdGxpbmVzKCkKICAgIGxpbmVjYWNoZS5jYWNo
-      ZVsiPHRhcmdldF9jb2RlPiJdID0gKGxlbihjb2RlKSwgTm9uZSwgY29kZV9s
-      aW5lcywgIjx0YXJnZXRfY29kZT4iKQogICAgcmV0dXJuIG1vZHVsZQoKCmRl
-      ZiBydW5fdXNlcl9jb2RlKGNvZGUpOgogICAgIiIiUnVuIHRoZSB1c2VyIGNv
-      ZGUgd2l0aCB0aGUgbWF0cGxvdGxpYiBpbnRlcmNlcHRvciBpbnN0YWxsZWQi
-      IiIKICAgICMgSW5zdGFsbCBtYXRwbG90bGliIGludGVyY2VwdG9yCiAgICBz
-      eXMubWV0YV9wYXRoLmluc2VydCgwLCBNYXRwbG90bGliRmluZGVyKCkpCgog
-      ICAgIyBTZXQgdXAgY2xlYW4gZW52aXJvbm1lbnQgZm9yIHVzZXIgY29kZQog
-      ICAgbW9kdWxlID0gc2V0dXBfdXNlcl9jb2RlX2Vudmlyb25tZW50KGNvZGUp
-      CgogICAgIyBDb21waWxlIGFuZCBydW4gdGhlIGNvZGUKICAgIGNvbXBpbGVk
-      ID0gY29tcGlsZShjb2RlLCAiPHRhcmdldF9jb2RlPiIsICJleGVjIikKCiAg
-      ICAjIEV4ZWN1dGUgaW4gdGhlIG1vZHVsZSdzIG5hbWVzcGFjZQogICAgZXhl
-      Yyhjb21waWxlZCwgbW9kdWxlLl9fZGljdF9fKSAgIyBweWxpbnQ6IGRpc2Fi
-      bGU9ZXhlYy11c2VkCgoKaWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIjoKICAg
-      IHRyeToKICAgICAgICAjIEdldCB0aGUgZW5jb2RlZCB1c2VyIGNvZGUKICAg
-      ICAgICB1c2VyX2NvZGUgPSBiYXNlNjQuYjY0ZGVjb2RlKCIiIntlbmNvZGVk
-      X2NvZGV9IiIiKS5kZWNvZGUoKQoKICAgICAgICAjIFJ1biB0aGUgY29kZQog
-      ICAgICAgIHJ1bl91c2VyX2NvZGUodXNlcl9jb2RlKQogICAgZXhjZXB0IEV4
-      Y2VwdGlvbjoKICAgICAgICAjIFByaW50IG9ubHkgdGhlIHJlbGV2YW50IHBh
-      cnRzIG9mIHRoZSB0cmFjZWJhY2sKICAgICAgICBleGNfdHlwZSwgZXhjX3Zh
-      bHVlLCBleGNfdGIgPSBzeXMuZXhjX2luZm8oKQoKICAgICAgICAjIEZpbHRl
-      ciB0cmFjZWJhY2sgdG8gb25seSBzaG93IHVzZXIgY29kZSBmcmFtZXMKICAg
-      ICAgICBmaWx0ZXJlZF90YiA9IFtdCiAgICAgICAgdGIgPSBleGNfdGIKICAg
-      ICAgICB3aGlsZSB0YiBpcyBub3QgTm9uZToKICAgICAgICAgICAgaWYgdGIu
-      dGJfZnJhbWUuZl9jb2RlLmNvX2ZpbGVuYW1lID09ICI8dGFyZ2V0X2NvZGU+
-      IjoKICAgICAgICAgICAgICAgIGZpbHRlcmVkX3RiLmFwcGVuZCh0YikKICAg
-      ICAgICAgICAgdGIgPSB0Yi50Yl9uZXh0CgogICAgICAgIGlmIGZpbHRlcmVk
-      X3RiOgogICAgICAgICAgICAjIENyZWF0ZSBhIG5ldyB0cmFjZWJhY2sgZnJv
-      bSB0aGUgZmlsdGVyZWQgZnJhbWVzCiAgICAgICAgICAgIGV4Y192YWx1ZS5f
-      X3RyYWNlYmFja19fID0gZmlsdGVyZWRfdGJbLTFdCiAgICAgICAgICAgIHRy
-      YWNlYmFjay5wcmludF9leGNlcHRpb24oZXhjX3R5cGUsIGV4Y192YWx1ZSwg
-      ZXhjX3ZhbHVlLl9fdHJhY2ViYWNrX18pCiAgICAgICAgZWxzZToKICAgICAg
-      ICAgICAgIyBGYWxsYmFjayBpZiBubyB1c2VyIGNvZGUgZnJhbWVzIGZvdW5k
-      IC0gcmFpc2UgdGhlIG9yaWdpbmFsIGV4Y2VwdGlvbiB0eXBlCiAgICAgICAg
-      ICAgICMgd2l0aCB0aGUgb3JpZ2luYWwgbWVzc2FnZSBidXQgY3JlYXRlIGEg
-      ZnJlc2ggdHJhY2ViYWNrCiAgICAgICAgICAgIHJhaXNlIGV4Y190eXBlKHN0
-      cihleGNfdmFsdWUpKSBmcm9tIE5vbmUKCiAgICAgICAgc3lzLmV4aXQoMSkK
-    BASE64
-    private_constant :PYTHON_CODE_WRAPPER
-  end
-end

data/lib/daytona/code_toolbox/sandbox_ts_code_toolbox.rb

@@ -1,30 +0,0 @@
-# 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)
-      # Prepend argv fix: ts-node places the script path at argv[1]; splice it out to match legacy node -e behaviour
-      encoded_code = Base64.strict_encode64("process.argv.splice(1, 1);\n" + code)
-
-      argv = params&.argv&.join(' ') || ''
-
-      # Pipe the base64-encoded code via stdin to avoid OS ARG_MAX limits on large payloads
-      # ts-node does not support - for stdin; use shell PID ($$) for the temp file — each code_run spawns its own
-      # shell process so $$ is unique across concurrent calls; cleaned up before exit
-      # npm_config_loglevel=error suppresses npm notice/warn output at source, preserving streaming and real errors
-      '_f=/tmp/dtn_$$.ts; ' \
-        "printf '%s' '#{encoded_code}' | base64 -d > \"$_f\"; " \
-        "npm_config_loglevel=error npx ts-node -T --ignore-diagnostics 5107 -O '{\"module\":\"CommonJS\"}' \"$_f\" #{argv}; " \
-        '_dtn_ec=$?; ' \
-        'rm -f "$_f"; ' \
-        'exit $_dtn_ec'
-    end
-  end
-end