daytona 0.165.0 → 0.167.0.alpha.1

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,29 +52,16 @@ 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
-      if env && !env.empty?
-        env.each_key do |key|
-          unless key.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
-            raise ArgumentError,
-                  "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}"
-      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))
+    def exec(command:, cwd: nil, env: nil, timeout: nil)
+      envs = env&.empty? ? nil : env
 
-      # 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 +81,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 +183,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 +204,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 +274,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 +535,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:)
@@ -465,12 +460,59 @@ module Daytona
                                                                  DaytonaApiClient::SandboxState::DESTROYED])
     end
 
+    # Forks the Sandbox, creating a new Sandbox with an identical filesystem.
+    # The forked Sandbox is a copy-on-write clone of the original. It starts
+    # with the same disk contents but operates independently from that point on.
+    #
+    # @param name [String, nil] Optional name for the forked Sandbox
+    # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s)
+    # @return [Daytona::Sandbox] The forked Sandbox
+    def experimental_fork(name: nil, timeout: DEFAULT_TIMEOUT) # rubocop:disable Metrics/MethodLength
+      forked_dto = nil
+      with_timeout(
+        timeout:,
+        message: "Sandbox #{id} fork failed to become ready within the #{timeout} seconds timeout period",
+        setup: proc {
+          forked_dto = sandbox_api.fork_sandbox(id, DaytonaApiClient::ForkSandbox.new(name:))
+        }
+      ) do
+        forked = Sandbox.new(
+          sandbox_dto: forked_dto,
+          config:,
+          sandbox_api:,
+          code_toolbox:,
+          otel_state:
+        )
+        forked.send(:wait_for_states, operation: OPERATION_START,
+                                      target_states: [DaytonaApiClient::SandboxState::STARTED])
+        return forked
+      end
+    end
+
+    # Creates a snapshot from the current state of the Sandbox.
+    # The Sandbox will temporarily enter a 'snapshotting' state and return to its previous state when complete.
+    #
+    # @param name [String] Name for the new snapshot
+    # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s)
+    # @return [void]
+    def experimental_create_snapshot(name:, timeout: DEFAULT_TIMEOUT)
+      with_timeout(
+        timeout:,
+        message: "Sandbox #{id} snapshot failed within the #{timeout} seconds timeout period",
+        setup: proc {
+          sandbox_api.create_sandbox_snapshot(id, DaytonaApiClient::CreateSandboxSnapshot.new(name:))
+          refresh
+        }
+      ) { wait_for_snapshot_complete }
+    end
+
     instrument :archive, :auto_archive_interval=, :auto_delete_interval=, :auto_stop_interval=,
                :create_ssh_access, :delete, :get_user_home_dir, :get_work_dir, :labels=,
                :preview_url, :create_signed_preview_url, :expire_signed_preview_url,
                :refresh, :refresh_activity, :revoke_ssh_access, :start, :recover, :stop,
                :create_lsp_server, :validate_ssh_access, :wait_for_sandbox_start,
                :wait_for_sandbox_stop, :resize, :wait_for_resize_complete,
+               :experimental_fork, :experimental_create_snapshot,
                component: 'Sandbox'
 
     private
@@ -593,5 +635,25 @@ module Daytona
 
     OPERATION_RESIZE = :resize
     private_constant :OPERATION_RESIZE
+
+    def wait_for_snapshot_complete
+      interval = INITIAL_POLL_INTERVAL
+      start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      while state == DaytonaApiClient::SandboxState::SNAPSHOTTING
+        refresh
+
+        if [DaytonaApiClient::SandboxState::ERROR, DaytonaApiClient::SandboxState::BUILD_FAILED].include?(state)
+          raise Sdk::Error,
+                "Sandbox #{id} snapshot failed with state: #{state}, error reason: #{error_reason}"
+        end
+
+        break if state != DaytonaApiClient::SandboxState::SNAPSHOTTING
+
+        sleep(interval)
+        if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_time > 5
+          interval = [interval * BACKOFF_MULTIPLIER, MAX_POLL_INTERVAL].min
+        end
+      end
+    end
   end
 end

data/lib/daytona/sdk/version.rb

@@ -2,6 +2,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.165.0'
+    VERSION = '0.167.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.165.0
+  version: 0.167.0.alpha.1
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.165.0
+        version: 0.167.0.alpha.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.165.0
+        version: 0.167.0.alpha.1
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.165.0
+        version: 0.167.0.alpha.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.165.0
+        version: 0.167.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