daytona 0.155.0 → 0.157.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 885fbb7e696fd3a33436ce01439b91c7a430dae30a86ae233eff51fa54a5cca5
-  data.tar.gz: a495d5928f1ae9ec8147aee393767a686ba28897212fecc9ebd19517440ff9e9
+  metadata.gz: 0e4b054d1b0090d6425189733b471adfb8de35c814cbebfe9ba1df64dd7cb37e
+  data.tar.gz: 69fdfe1572c89aa67bf804a2bd751edb2b73f8c6d2b52add512f79ec0459b5ec
 SHA512:
-  metadata.gz: 7ffdad63ef44ff5cb1dd8b577163e68779c2e196680a36a478cc33b4c831e536150e0ed5d1c718c7021a51aee73daf01fb31209eb7a6d5a046618585b4d859ed
-  data.tar.gz: 4346643bac10c6cbbcbe860ca9ea0eaafd54e286c4dac53ec8ec98e85431816b272aa2b64dbc22de702c6fda08f998e7dd4e2e7d519055e13b16595b5f131c2e
+  metadata.gz: 249970151c4a5c4043ebff0bcaf3c885ed723b7b0742b6016af95c4bbdfa3e8d23c287936ce32a0b7b4dfc2bc6ab0261b75e8fc29421485528fda670f44960c5
+  data.tar.gz: 396607d006c45ea9add617beba268f15c0176af2778249b1c94414c9ab2e80f0be831df2cfe7c520c61173f79e15ca1d70b827e24c3c8a1760d07ceba229bb6d

data/lib/daytona/code_toolbox/sandbox_js_code_toolbox.rb

@@ -5,15 +5,17 @@ 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(code)
+      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?
 
-      # 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\"' "
+      # 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

@@ -10,22 +10,21 @@ module Daytona
     # @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.encode64(code)
+      encoded_code = Base64.strict_encode64(code)
 
       # Override plt.show() method if matplotlib is imported
       if matplotlib_imported?(code)
-        encoded_code = Base64.encode64(
+        encoded_code = Base64.strict_encode64(
           Base64.decode64(PYTHON_CODE_WRAPPER).gsub('{encoded_code}', encoded_code)
         )
       end
 
       argv = params&.argv&.join(' ') || ''
 
-      # Execute the bootstrapper code directly
+      # 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
-
-      " sh -c 'python3 -u -c \"exec(__import__(\\\"base64\\\").b64decode(\\\"\\\"\\\"#{encoded_code}\\\"\\\"\\\")" \
-        ".decode())\" #{argv}' "
+      "printf '%s' '#{encoded_code}' | base64 -d | python3 -u - #{argv}"
     end
 
     private

data/lib/daytona/code_toolbox/sandbox_ts_code_toolbox.rb

@@ -10,14 +10,21 @@ module Daytona
     # @param params [Daytona::CodeRunParams, nil] Optional parameters for code execution
     # @return [String] The command to run the TypeScript code
     def get_run_command(code, params = nil)
-      encoded_code = Base64.encode64(code)
+      # 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(' ') || ''
 
-      # Execute TypeScript code using ts-node with ESM support
-      " sh -c 'echo #{encoded_code} | base64 --decode | npx ts-node -O " \
-        "\"{\\\"module\\\":\\\"CommonJS\\\"}\" -e \"$(cat)\" x #{argv} 2>&1 | grep -vE " \
-        "\"npm notice\"' "
+      # 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

data/lib/daytona/config.rb

@@ -52,46 +52,47 @@ module Daytona
       target: nil,
       _experimental: nil
     )
-      # 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)
+      @env_reader = daytona_env_reader
+
+      @api_key = api_key || @env_reader.call('DAYTONA_API_KEY')
+      @jwt_token = jwt_token || @env_reader.call('DAYTONA_JWT_TOKEN')
+      @api_url = api_url || @env_reader.call('DAYTONA_API_URL') || API_URL
+      @target = target || @env_reader.call('DAYTONA_TARGET')
+      @organization_id = organization_id || @env_reader.call('DAYTONA_ORGANIZATION_ID')
       @_experimental = _experimental
     end
 
-    private
+    # Reads a DAYTONA_-prefixed environment variable using the same precedence
+    # as the Config initializer: runtime ENV first, then .env.local, then .env.
+    # Only names starting with DAYTONA_ are accepted.
+    #
+    # @param name [String] The environment variable name. Must start with DAYTONA_.
+    # @return [String, nil] The value of the environment variable, or nil if not set.
+    # @raise [ArgumentError] If name does not start with DAYTONA_.
+    def read_env(name)
+      @env_reader.call(name)
+    end
 
-    # 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
-      ]
+    private
 
+    # Returns a lambda that looks up DAYTONA_-prefixed env vars without writing to ENV.
+    # Files are parsed once; lookups check runtime env first, then .env.local, then .env.
+    def daytona_env_reader
+      file_vars = {}
       env_file = File.join(Dir.pwd, '.env')
+      file_vars.merge!(daytona_filter(Dotenv.parse(env_file))) if File.exist?(env_file)
       env_local_file = File.join(Dir.pwd, '.env.local')
+      file_vars.merge!(daytona_filter(Dotenv.parse(env_local_file))) if File.exist?(env_local_file)
 
-      # 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)
+      lambda do |name|
+        raise ArgumentError, "Variable must start with 'DAYTONA_', got '#{name}'" unless name.start_with?('DAYTONA_')
 
-      # 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)
+        ENV.key?(name) ? ENV[name] : file_vars[name]
       end
     end
+
+    def daytona_filter(env_hash)
+      env_hash.select { |k, _| k.start_with?('DAYTONA_') }
+    end
   end
 end

data/lib/daytona/daytona.rb

@@ -33,7 +33,7 @@ module Daytona
       @config = config
       ensure_access_token_defined
 
-      otel_enabled = config._experimental&.dig('otel_enabled') || ENV['DAYTONA_EXPERIMENTAL_OTEL_ENABLED'] == 'true'
+      otel_enabled = config._experimental&.dig('otel_enabled') || config.read_env('DAYTONA_EXPERIMENTAL_OTEL_ENABLED') == 'true'
       @otel_state = (::Daytona.init_otel(Sdk::VERSION) if otel_enabled)
 
       @api_client = build_api_client
@@ -149,10 +149,13 @@ module Daytona
         raise Sdk::Error, 'auto_archive_interval must be a non-negative integer'
       end
 
+      labels = params.labels&.dup || {}
+      labels[LABEL_CODE_TOOLBOX_LANGUAGE] = params.language.to_s if params.language
+
       create_sandbox = DaytonaApiClient::CreateSandbox.new(
         user: params.os_user,
         env: params.env_vars || {},
-        labels: params.labels,
+        labels: labels,
         public: params.public,
         target: config.target,
         auto_stop_interval: params.auto_stop_interval,

data/lib/daytona/process.rb

@@ -54,21 +54,23 @@ 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/AbcSize, Metrics/MethodLength
-      command = "echo '#{Base64.encode64(command)}' | base64 -d | sh"
-
+    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}=$(echo '#{Base64.encode64(value)}' | base64 -d)"
-        end.join(';')
+          "export #{key}=\"$(echo '#{Base64.strict_encode64(value)}' | base64 -d)\""
+        end.join('; ')
         command = "#{safe_env_exports}; #{command}"
       end
 
-      command = "sh -c \"#{command}\""
-
       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"))
+      artifacts = parse_output(response.result.split("\n", -1))
 
       # Create new response with processed output and charts
       ExecuteResponse.new(
@@ -546,15 +548,17 @@ module Daytona
     # @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
-          artifacts.stdout += "#{line}\n"
+          stdout_lines << line
         end
       end
 
+      artifacts.stdout = stdout_lines.join("\n")
       artifacts
     end
 

data/lib/daytona/sandbox.rb

@@ -365,13 +365,14 @@ module Daytona
     # Stops the Sandbox and waits for it to be stopped.
     #
     # @param timeout [Numeric] Maximum wait time in seconds (defaults to 60 s).
+    # @param force [Boolean] If true, uses SIGKILL instead of SIGTERM (defaults to false).
     # @return [void]
-    def stop(timeout = DEFAULT_TIMEOUT) # rubocop:disable Metrics/MethodLength
+    def stop(timeout = DEFAULT_TIMEOUT, force: false) # rubocop:disable Metrics/MethodLength
       with_timeout(
         timeout:,
         message: "Sandbox #{id} failed to become stopped within the #{timeout} seconds timeout period",
         setup: proc {
-          sandbox_api.stop_sandbox(id)
+          sandbox_api.stop_sandbox(id, { force: force })
           refresh
         }
       ) do

data/lib/daytona/sdk/version.rb

@@ -2,6 +2,6 @@
 
 module Daytona
   module Sdk
-    VERSION = '0.155.0'
+    VERSION = '0.157.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: daytona
 version: !ruby/object:Gem::Version
-  version: 0.155.0
+  version: 0.157.0
 platform: ruby
 authors:
 - Daytona Platforms Inc.
@@ -85,28 +85,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.155.0
+        version: 0.157.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.155.0
+        version: 0.157.0
 - !ruby/object:Gem::Dependency
   name: daytona_toolbox_api_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.155.0
+        version: 0.157.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.155.0
+        version: 0.157.0
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement