daytona 0.126.0.pre.alpha.5 → 0.134.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bddc30387b54eb59515ee8d562a84f60cc8897dada6124e4b810d87591628a33
-  data.tar.gz: fc2fed7fb2321cf274be4b4ac69165a155e9982bacd936522745adbdeec057e1
+  metadata.gz: e7ccf2ea96861ef33410f2dc49e0e85243aabf6608d9d1b10e657507f4030d02
+  data.tar.gz: 9816f06a64493152d37bd202d00a8180212e6b9925af3c9d3b8deb11cad2d8f6
 SHA512:
-  metadata.gz: 4d9a431c134fb2eb226fe43500e41e2c00f434c725b8c5f68a5fbba57a11b0a111680be4ecb06e97896c5294015ee08bc91357c8e3f03564bc23f9d2c231372b
-  data.tar.gz: dda0466e92992558b6bcb53aec5a7971be1d8da8a0843c2952c958a01433ef9e2f4073116d54ed5e1eb51ddaacbe78455205e271445cb19cfcf262421cbae86d
+  metadata.gz: ccafd445c1c0f927eb9991cc051b2ad0d063adcd960615b1f21d6a154e2b9d5d3fbd424b7ffbd10aedcb7ec1dc2c2e30202dcd2182305f251f50c093baa03303
+  data.tar.gz: 6ee5305671de7d7c351a28b29f1a5210f08bae5fe6d992dffb888ca93e0795e21f55dd5f845b97c853b31323c0daf557c4e651ea9de65f9763854e7747cbda41

data/.rubocop.yml

@@ -7,7 +7,7 @@ AllCops:
 
 Layout/LineLength:
   AllowedPatterns: ['\A\s*#']
-  IgnoreCopDirectives: true
+  AllowCopDirectives: true
 
 Style/Documentation:
   Enabled: false

data/README.md

@@ -86,13 +86,14 @@ From the repository root:
 ```bash
 # Set your RubyGems API key and version
 export RUBYGEMS_API_KEY="your-rubygems-api-key"
-export RUBYGEMS_PKG_VERSION="X.Y.Z" # pre-release format example: "X.Y.Z-alpha.1"
+export RUBYGEMS_PKG_VERSION="X.Y.Z" # pre-release format example: "X.Y.Z.alpha.1"
 
 # Publish (builds and publishes all Ruby gems)
 yarn nx publish sdk-ruby
 ```
 
 This will automatically:
+
 - Set the version for all Ruby gems (api-client, toolbox-api-client, sdk)
 - Build all gems in the correct dependency order
 - Publish to RubyGems

data/lib/daytona/code_interpreter.rb

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

data/lib/daytona/code_toolbox/sandbox_js_code_toolbox.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Daytona
+  class SandboxJsCodeToolbox
+    def get_run_command(code, params = nil)
+      # Encode the provided code in base64
+      base64_code = Base64.strict_encode64(code)
+
+      # Build command-line arguments string
+      argv = ''
+      argv = params.argv.join(' ') if params&.argv && !params.argv.empty?
+
+      # Combine everything into the final command for JavaScript
+      " sh -c 'echo #{base64_code} | base64 --decode | node -e \"$(cat)\" #{argv} 2>&1 | grep -vE \"npm notice\"' "
+    end
+  end
+end

data/lib/daytona/common/code_interpreter.rb

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

data/lib/daytona/common/snapshot.rb

@@ -16,15 +16,21 @@ module Daytona
     # @return [Array<String>, nil] Entrypoint of the snapshot
     attr_reader :entrypoint
 
+    # @return [String, nil] ID of the region where the snapshot will be available.
+    #   Defaults to organization default region if not specified.
+    attr_reader :region_id
+
     # @param name [String] Name of the snapshot
     # @param image [String, Daytona::Image] Image of the snapshot
     # @param resources [Daytona::Resources, nil] Resources of the snapshot
     # @param entrypoint [Array<String>, nil] Entrypoint of the snapshot
-    def initialize(name:, image:, resources: nil, entrypoint: nil)
+    # @param region_id [String, nil] ID of the region where the snapshot will be available
+    def initialize(name:, image:, resources: nil, entrypoint: nil, region_id: nil)
       @name = name
       @image = image
       @resources = resources
       @entrypoint = entrypoint
+      @region_id = region_id
     end
   end
 

data/lib/daytona/computer_use.rb

@@ -67,7 +67,7 @@ module Daytona
       #   right_click = sandbox.computer_use.mouse.click(x: 100, y: 200, button: 'right')
       def click(x:, y:, button: 'left', double: false) # rubocop:disable Naming/MethodParameterName
         request = DaytonaToolboxApiClient::MouseClickRequest.new(x:, y:, button:, double:)
-        toolbox_api.click_mouse(request)
+        toolbox_api.click(request)
       rescue StandardError => e
         raise Sdk::Error, "Failed to click mouse: #{e.message}"
       end
@@ -87,7 +87,7 @@ module Daytona
       #   puts "Dragged from #{result.from_x},#{result.from_y} to #{result.to_x},#{result.to_y}"
       def drag(start_x:, start_y:, end_x:, end_y:, button: 'left')
         request = DaytonaToolboxApiClient::MouseDragRequest.new(start_x:, start_y:, end_x:, end_y:, button:)
-        toolbox_api.drag_mouse(request)
+        toolbox_api.drag(request)
       rescue StandardError => e
         raise Sdk::Error, "Failed to drag mouse: #{e.message}"
       end
@@ -109,7 +109,7 @@ module Daytona
       #   scroll_down = sandbox.computer_use.mouse.scroll(x: 100, y: 200, direction: 'down', amount: 5)
       def scroll(x:, y:, direction:, amount: 1) # rubocop:disable Naming/MethodParameterName
         request = DaytonaToolboxApiClient::MouseScrollRequest.new(x:, y:, direction:, amount:)
-        toolbox_api.scroll_mouse(request)
+        toolbox_api.scroll(request)
         true
       rescue StandardError => e
         raise Sdk::Error, "Failed to scroll mouse: #{e.message}"

data/lib/daytona/config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'dotenv'
+
 module Daytona
   class Config
     API_URL = 'https://app.daytona.io/api'
@@ -37,17 +39,51 @@ module Daytona
     # @param organization_id [String, nil] Daytona organization ID. Defaults to ENV['DAYTONA_ORGANIZATION_ID'].
     # @param target [String, nil] Daytona target. Defaults to ENV['DAYTONA_TARGET'].
     def initialize(
-      api_key: ENV.fetch('DAYTONA_API_KEY', nil),
-      jwt_token: ENV.fetch('DAYTONA_JWT_TOKEN', nil),
-      api_url: ENV.fetch('DAYTONA_API_URL', API_URL),
-      organization_id: ENV.fetch('DAYTONA_ORGANIZATION_ID', nil),
-      target: ENV.fetch('DAYTONA_TARGET', nil)
+      api_key: nil,
+      jwt_token: nil,
+      api_url: nil,
+      organization_id: nil,
+      target: nil
     )
-      @api_key = api_key
-      @jwt_token = jwt_token
-      @api_url = api_url
-      @target = target
-      @organization_id = organization_id
+      # Load environment variables from .env and .env.local files
+      # Files are loaded from the current working directory (where the code is executed)
+      load_env_files
+
+      @api_key = api_key || ENV.fetch('DAYTONA_API_KEY', nil)
+      @jwt_token = jwt_token || ENV.fetch('DAYTONA_JWT_TOKEN', nil)
+      @api_url = api_url || ENV.fetch('DAYTONA_API_URL', API_URL)
+      @target = target || ENV.fetch('DAYTONA_TARGET', nil)
+      @organization_id = organization_id || ENV.fetch('DAYTONA_ORGANIZATION_ID', nil)
+    end
+
+    private
+
+    # Load only Daytona-specific environment variables from .env and .env.local files
+    # Only loads variables that are not already set in the runtime environment
+    # .env.local overrides .env
+    # Files are loaded from the current working directory
+    def load_env_files
+      # Daytona-specific variables we want to load
+      daytona_vars = %w[
+        DAYTONA_API_KEY
+        DAYTONA_API_URL
+        DAYTONA_TARGET
+        DAYTONA_JWT_TOKEN
+        DAYTONA_ORGANIZATION_ID
+      ]
+
+      env_file = File.join(Dir.pwd, '.env')
+      env_local_file = File.join(Dir.pwd, '.env.local')
+
+      # Parse .env files using dotenv (doesn't set ENV automatically)
+      env_from_file = {}
+      env_from_file.merge!(Dotenv.parse(env_file)) if File.exist?(env_file)
+      env_from_file.merge!(Dotenv.parse(env_local_file)) if File.exist?(env_local_file)
+
+      # Only set Daytona-specific variables that aren't already in runtime
+      daytona_vars.each do |var|
+        ENV[var] = env_from_file[var] if env_from_file.key?(var) && !ENV.key?(var)
+      end
     end
   end
 end

data/lib/daytona/daytona.rb

@@ -36,8 +36,9 @@ module Daytona
       @volume = VolumeService.new(DaytonaApiClient::VolumesApi.new(api_client))
       @object_storage_api = DaytonaApiClient::ObjectStorageApi.new(api_client)
       @snapshots_api = DaytonaApiClient::SnapshotsApi.new(api_client)
-      @snapshot = SnapshotService.new(snapshots_api:, object_storage_api:)
-      @proxy_toolbox_url = nil
+      @snapshot = SnapshotService.new(snapshots_api:, object_storage_api:, default_region_id: config.target)
+      @proxy_toolbox_url_cache = {}
+      @proxy_toolbox_url_mutex = Mutex.new
     end
 
     # Creates a sandbox with the specified parameters
@@ -180,9 +181,15 @@ module Daytona
       response = sandbox_api.create_sandbox(create_sandbox)
 
       if response.state == DaytonaApiClient::SandboxState::PENDING_BUILD && on_snapshot_create_logs
-        uri = URI.parse(sandbox_api.api_client.config.base_url)
-        uri.path = "/api/sandbox/#{response.id}/build-logs"
-        uri.query = 'follow=true'
+        # Wait for state to change from PENDING_BUILD before fetching logs
+        while response.state == DaytonaApiClient::SandboxState::PENDING_BUILD
+          sleep(1)
+          response = sandbox_api.get_sandbox(response.id)
+        end
+
+        # Get build logs URL from API
+        build_logs_response = sandbox_api.get_build_logs_url(response.id)
+        uri = URI.parse("#{build_logs_response.url}?follow=true")
 
         headers = {}
         sandbox_api.api_client.update_params_for_auth!(headers, nil, ['bearer'])
@@ -238,15 +245,27 @@ module Daytona
         config:,
         sandbox_api:,
         code_toolbox:,
-        get_proxy_toolbox_url: method(:proxy_toolbox_url)
+        get_proxy_toolbox_url: proc { |sandbox_id, region_id| proxy_toolbox_url(sandbox_id, region_id) }
       )
     end
 
-    # Gets the proxy toolbox URL from the config API (lazy loaded)
+    # Gets the proxy toolbox URL from the sandbox API (cached per region)
     #
+    # @param sandbox_id [String] The sandbox ID
+    # @param region_id [String] The region ID
     # @return [String] The proxy toolbox URL
-    def proxy_toolbox_url
-      @proxy_toolbox_url ||= @config_api.config_controller_get_config.proxy_toolbox_url
+    def proxy_toolbox_url(sandbox_id, region_id)
+      # Return cached URL if available
+      return @proxy_toolbox_url_cache[region_id] if @proxy_toolbox_url_cache.key?(region_id)
+
+      # Use mutex to ensure thread-safe caching
+      @proxy_toolbox_url_mutex.synchronize do
+        # Double-check after acquiring lock
+        return @proxy_toolbox_url_cache[region_id] if @proxy_toolbox_url_cache.key?(region_id)
+
+        # Fetch and cache the URL
+        @proxy_toolbox_url_cache[region_id] = sandbox_api.get_toolbox_proxy_url(sandbox_id).url
+      end
     end
 
     # Converts a language to a code toolbox
@@ -260,6 +279,8 @@ module Daytona
         SandboxPythonCodeToolbox.new
       when SandboxTsCodeToolbox, CodeLanguage::TYPESCRIPT
         SandboxTsCodeToolbox.new
+      when CodeLanguage::JAVASCRIPT
+        SandboxJsCodeToolbox.new
       else
         raise Sdk::Error, "Unsupported language: #{language}"
       end