withruntime 0.1.0 → 0.2.0

data/lib/withruntime/tar.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require "stringio"
+require "tmpdir"
 require "zlib"
 
 module WithRuntime
@@ -65,41 +67,224 @@ module WithRuntime
       gzip(tar << ("\0".b * 1024))
     end
 
-    # Unpacks a gzipped tar into target, refusing any entry that would land outside it, and links.
+    # A folder that did not arrive whole: tar in the sandbox stopped part way
+    # (a file it may not read, one that changed as it was read), which ends
+    # the gzip stream short, or the connection was lost.
+    def cut_short
+      Error.new("The folder's archive arrived cut short: tar in the sandbox stopped part way, or the " \
+                "connection was lost. Nothing was written.",
+                code: "download_incomplete",
+                hint: "Try again. If it fails the same way, a file in the folder cannot be read by the " \
+                      "sandbox user or changes as it is read.")
+    end
+
+    # Unpacks a whole gzipped tar held in memory into target, by Unpacker's rules.
     def unpack(archive, target)
-      data = Zlib::GzipReader.new(StringIO.new(archive)).read.b
-      root = File.expand_path(target)
-      FileUtils.mkdir_p(root)
-      field = ->(start, length) { data[start, length].split("\0", 2).first.to_s.force_encoding("UTF-8") }
-      offset = 0
-      long_name = nil
-      while offset + 512 <= data.bytesize
-        break if data[offset, 512].count("\0") == 512
-
-        size = field.call(offset + 124, 12).strip.then { |text| text.empty? ? 0 : text.to_i(8) }
-        type = data[offset + 156]
-        prefix = field.call(offset + 345, 155)
-        name = long_name || (prefix.empty? ? field.call(offset, 100) : "#{prefix}/#{field.call(offset, 100)}")
-        long_name = nil
-        mode = field.call(offset + 100, 8).strip.then { |text| text.empty? ? 0o644 : text.to_i(8) }
-        body = data[offset + 512, size]
-        offset += 512 + (((size + 511) / 512) * 512)
-        if type == "L"
-          long_name = body.split("\0", 2).first.force_encoding("UTF-8")
-          next
+      unpacker = Unpacker.new(target)
+      begin
+        unpacker.feed(archive)
+        unpacker.finish
+      ensure
+        unpacker.discard
+      end
+    end
+
+    # Unpacks a gzipped tar fed to it a chunk at a time into a target folder,
+    # holding no more than a chunk. Entries land only inside the target, and
+    # symbolic links are not made; a hard link lands as the file it names. It unpacks into a folder beside the target and moves
+    # it into place only once the whole archive arrived (+finish+), so an
+    # archive cut short leaves nothing behind that could pass for the folder.
+    # A target that exists is merged into, files of the same name replaced,
+    # never through a link in it. +discard+ removes what was unpacked if
+    # +finish+ was never reached.
+    class Unpacker
+      def initialize(target)
+        @final = File.expand_path(target)
+        FileUtils.mkdir_p(File.dirname(@final))
+        @staging = Dir.mktmpdir("#{File.basename(@final)}.runtime-partial-", File.dirname(@final))
+        @root = File.realpath(@staging)
+        @inflate = Zlib::Inflate.new(Zlib::MAX_WBITS + 16)
+        @held = "".b
+        @entry = nil
+        @left = 0
+        @padding = 0
+        @long = nil
+        @long_link = nil
+        @ended = false
+      end
+
+      def feed(data)
+        begin
+          @held << @inflate.inflate(data)
+        rescue Zlib::Error
+          raise Tar.cut_short
+        end
+        nil while step
+      end
+
+      # Checks the archive arrived whole, then puts it in place.
+      def finish
+        raise Tar.cut_short unless @inflate.finished? && @ended
+
+        if File.exist?(@final) || File.symlink?(@final)
+          final = File.realpath(@final)
+          merge(@root, final, final)
+        else
+          File.rename(@staging, @final)
         end
-        name = name.delete_prefix("./")
-        next if name.empty? || name == "." || name == "./"
-
-        destination = File.expand_path(name, root)
-        raise IOError, "Refusing an archive entry outside the target: #{name}" unless destination.start_with?("#{root}/")
-
-        case type
-        when "5" then FileUtils.mkdir_p(destination)
-        when "0", "\0", "7"
-          FileUtils.mkdir_p(File.dirname(destination))
-          File.binwrite(destination, body)
-          File.chmod(mode & 0o777, destination)
+      end
+
+      def discard
+        @entry[:file]&.close if @entry.is_a?(Hash)
+        FileUtils.rm_rf(@staging)
+      end
+
+      private
+
+      def step
+        if @ended
+          @held.clear
+          return false
+        end
+        if @entry.nil?
+          return false if @held.bytesize < 512
+
+          header = @held.slice!(0, 512)
+          if header.count("\0") == 512
+            @ended = true
+          else
+            begin_entry(header)
+          end
+          return true
+        end
+        if @left.positive?
+          return false if @held.empty?
+
+          part = @held.slice!(0, @left)
+          @left -= part.bytesize
+          @entry[:file]&.write(part)
+          @entry[:long]&.<<(part)
+          return false if @left.positive?
+
+          end_body
+          return true
+        end
+        if @padding.positive?
+          return false if @held.empty?
+
+          @padding -= @held.slice!(0, @padding).bytesize
+          return false if @padding.positive?
+        end
+        @entry = nil
+        true
+      end
+
+      def field(header, start, length) = header[start, length].split("\0", 2).first.to_s.force_encoding("UTF-8")
+
+      def begin_entry(header)
+        size = if header.getbyte(124) & 0x80 != 0
+                 header[125, 11].bytes.inject(0) { |sum, byte| (sum << 8) | byte }
+               else
+                 field(header, 124, 12).strip.then { |text| text.empty? ? 0 : text.to_i(8) }
+               end
+        type = header[156]
+        prefix = field(header, 345, 155)
+        name = @long || (prefix.empty? ? field(header, 0, 100) : "#{prefix}/#{field(header, 0, 100)}")
+        link = @long_link || field(header, 157, 100)
+        @long = nil
+        @long_link = nil
+        @long_link = nil
+        mode = field(header, 100, 8).strip.then { |text| text.empty? ? 0o644 : text.to_i(8) }
+        @left = size
+        @padding = -size % 512
+        @entry = {}
+        if %w[L K x].include?(type)
+          @entry = { long: "".b, type: type }
+        else
+          name = name.delete_prefix("./")
+          unless name.empty? || name == "." || name == "./"
+            destination = File.expand_path(name, @root)
+            raise IOError, "Refusing an archive entry outside the target: #{name}" unless destination.start_with?("#{@root}/")
+
+            case type
+            when "5" then FileUtils.mkdir_p(destination)
+            when "1" then hard_link(destination, link, name)
+            when "0", "\0", "7"
+              FileUtils.mkdir_p(File.dirname(destination))
+              # A name already unpacked may share its file with a hard link;
+              # writing through it would change the link's copy too.
+              File.unlink(destination) if File.exist?(destination) || File.symlink?(destination)
+              @entry = { file: File.open(destination, "wb"), path: destination, mode: mode }
+            end
+          end
+        end
+        end_body if @left.zero?
+      end
+
+      def end_body
+        if @entry[:file]
+          @entry[:file].close
+          File.chmod(@entry[:mode] & 0o777, @entry[:path])
+        elsif @entry[:long]
+          body = @entry[:long]
+          case @entry[:type]
+          when "L" then @long = body.split("\0", 2).first.force_encoding("UTF-8")
+          when "K" then @long_link = body.split("\0", 2).first.force_encoding("UTF-8")
+          else @long = pax_path(body)
+          end
+        end
+        @entry = {}
+      end
+
+      # A second name for a file the archive already carried: tar writes the
+      # first name as a file and every other as a hard link to it. The link
+      # names a plain file unpacked earlier in this archive, or the unpack
+      # fails; it never reaches outside or ahead.
+      def hard_link(destination, link, name)
+        source = File.expand_path(link.delete_prefix("./"), @root)
+        unless source.start_with?("#{@root}/") && !link.start_with?("/")
+          raise IOError, "Refusing an archive hard link that leads outside the target: #{name} -> #{link}"
+        end
+        unless File.file?(source) && !File.symlink?(source)
+          raise IOError, "Refusing an archive hard link to a file it does not carry: #{name} -> #{link}"
+        end
+        return if source == destination
+
+        FileUtils.mkdir_p(File.dirname(destination))
+        File.unlink(destination) if File.exist?(destination) || File.symlink?(destination)
+        begin
+          File.link(source, destination)
+        rescue SystemCallError
+          FileUtils.cp(source, destination, preserve: true)
+        end
+      end
+
+      # A pax header's path record, if it has one.
+      def pax_path(body)
+        until body.empty?
+          length = body[/\A\d+/].to_i
+          key, value = body[0, length].split(" ", 2).last.chomp.split("=", 2)
+          return value.force_encoding("UTF-8") if key == "path"
+
+          body = body[length..]
+        end
+        nil
+      end
+
+      def merge(from, to, root)
+        Dir.children(from).each do |name|
+          source = File.join(from, name)
+          destination = File.join(to, name)
+          through = destination.delete_prefix("#{root}/").split("/").each_with_object([root]) { |part, way| way << File.join(way.last, part) }
+          if through.drop(1).any? { |path| File.symlink?(path) }
+            raise IOError, "Refusing an archive entry that passes through a link: #{destination.delete_prefix("#{root}/")}"
+          end
+
+          if File.directory?(source) && File.directory?(destination)
+            merge(source, destination, root)
+          else
+            File.rename(source, destination)
+          end
         end
       end
     end

data/lib/withruntime/transport.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "digest"
 require "json"
 require "net/http"
 require "securerandom"
@@ -10,7 +11,7 @@ module WithRuntime
   # product: the same rules as the JavaScript, Python, Go and Java SDKs. Writes
   # carry an idempotency key, made per call and kept across the client's own
   # retries; transport failures, 429, 502, 503 and 504 are retried with backoff
-  # and jitter; a create waits out a full trial, quota or region.
+  # and jitter; a create waits out full slots without credit, a full quota or a full region.
   class Transport
     class OpeningCancelled < IOError; end
     class Cancellation
@@ -41,6 +42,21 @@ module WithRuntime
         action&.call
       end
     end
+    # How long one attempt waits for its answer to start. The API starts every
+    # answer within 120 s: Caddy answers 503 itself past that, and a longer call
+    # gets its 200 at 90 s and then its JSON (runtime-late-answer). An attempt
+    # with no answer by then is talking to a server that is gone, such as a
+    # controller that died with the call in flight while its address moved to
+    # the new leader: a client that only waits sends nothing the new leader
+    # could refuse (the leader drill on vin-5, 4 October 2026). It is sent
+    # again under the same key.
+    ANSWER_START = 125.0
+    class << self
+      attr_writer :answer_start
+
+      def answer_start = @answer_start || ANSWER_START
+    end
+
     NETWORK_ERRORS = [IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError,
                       Net::HTTPBadResponse, Net::ProtocolError, EOFError].freeze
 
@@ -68,8 +84,8 @@ module WithRuntime
 
     # The value of a JSON call: a Hash, an Array or nil.
     def json(method, path, query: nil, body: nil, **options)
-      with_connection(options) do |http|
-        response = send_call(http, method, path, query: query, body: body, **options)
+      with_connection(options, method) do |http, admitted|
+        response = send_call(http, method, path, query: query, body: body, **admitted)
         text = response.body.to_s
         text.strip.empty? ? nil : JSON.parse(text)
       rescue JSON::ParserError => e
@@ -77,14 +93,79 @@ module WithRuntime
       end
     end
 
+    # A GET's body to the block a chunk at a time as it arrives. A connection
+    # lost part way is raised, never retried, so no chunk is given twice.
+    def chunks(path, query: nil, accept: "application/octet-stream", &block)
+      with_connection({}, "GET") do |http, admitted|
+        send_call(http, "GET", path, query: query, accept: accept, no_retry: true, **admitted, &block)
+      end
+      nil
+    end
+
     def bytes(method, path, query: nil, body: nil, **options)
-      with_connection(options) do |http|
-        send_call(http, method, path, query: query, body: body, **options).body.to_s.b
+      with_connection(options, method) do |http, admitted|
+        send_call(http, method, path, query: query, body: body, **admitted).body.to_s.b
+      end
+    end
+
+    # A file's bytes, checked against the length (x-content-length) and
+    # SHA-256 (x-content-sha256) the API sent with them: a stream that broke
+    # can arrive as one that ended, short. A short or different body is read
+    # again twice, then download_incomplete.
+    def file_bytes(path, query: nil, accept: "application/octet-stream", **options)
+      attempt = 0
+      loop do
+        response = with_connection(options, "GET") do |http, admitted|
+          send_call(http, "GET", path, query: query, accept: accept, **admitted)
+        end
+        body = response.body.to_s.b
+        problem = Transport.check_body(response, body)
+        return body unless problem
+        raise problem if attempt >= 2
+
+        sleep(backoff(attempt))
+        attempt += 1
+      end
+    end
+
+    # Why a whole file body cannot be trusted, or nil when it can.
+    def self.check_body(response, body)
+      expected = response["x-content-length"]
+      if expected&.match?(/\A\d+\z/) && body.bytesize != expected.to_i
+        return Error.new("The download ended at #{body.bytesize} of #{expected} bytes.",
+                         code: "download_incomplete",
+                         hint: "Read the file again; nothing was written for this read.",
+                         details: { "received" => body.bytesize, "expected" => expected.to_i })
+      end
+      sha256 = response["x-content-sha256"]
+      return nil if sha256.nil? || sha256.empty? || Digest::SHA256.hexdigest(body).casecmp?(sha256)
+
+      Error.new("The file's bytes did not match the SHA-256 the API sent with them.",
+                code: "download_incomplete", hint: "Read the file again.")
+    end
+
+    # The status a late answer's body failed with, or 200 when it is an
+    # answer. An API error is a body of `error` alone, with a code; an answer
+    # may carry an `error` of its own (a code cell's exception) beside other
+    # fields. A body that is not JSON was cut or garbled: 502.
+    def self.late_failure(text)
+      body = begin
+        JSON.parse(text)
+      rescue JSON::ParserError
+        return 502
       end
+      return 200 unless body.is_a?(Hash) && body.size == 1
+      error = body["error"]
+      return 200 unless error.is_a?(Hash) && error["code"].is_a?(String)
+
+      status = error["status"]
+      status.is_a?(Numeric) && status >= 400 ? status.to_i : 500
     end
 
     # Newline-delimited JSON events as they arrive, one Hash per event, on a
-    # connection of their own.
+    # connection of their own. A connection lost after the first event is
+    # raised, never retried, so no event is given twice; the caller resumes
+    # from its cursor.
     def events(method, path, query: nil, body: nil, cancel: nil, **options, &block)
       return enum_for(:events, method, path, query: query, body: body, cancel: cancel, **options) unless block
 
@@ -205,7 +286,12 @@ module WithRuntime
       end
     end
 
-    def with_connection(_options)
+    # A connection from the pool, waited for within the call's own deadline;
+    # the wait is taken off it, so a queued call expires as an unqueued one
+    # would, without sending anything.
+    def with_connection(options, method)
+      limit = options[:timeout] || @timeout
+      deadline = now + limit
       http = @lock.synchronize do
         loop do
           break @idle.pop unless @idle.empty?
@@ -213,12 +299,18 @@ module WithRuntime
             @open += 1
             break connect
           end
-          @freed.wait(@lock)
+          left = deadline - now
+          raise connection_error(true, method != "GET", options[:key]) if left <= 0
+
+          @freed.wait(@lock, left)
         end
       end
       healthy = false
       begin
-        result = yield http
+        left = deadline - now
+        raise connection_error(true, method != "GET", options[:key]) if left <= 0
+
+        result = yield http, options.merge(timeout: left)
         healthy = true
         result
       ensure
@@ -234,6 +326,35 @@ module WithRuntime
       end
     end
 
+    def deadline_watchdog(http, seconds)
+      Thread.new do
+        Thread.current.report_on_exception = false
+        sleep(seconds)
+        begin
+          http.instance_variable_get(:@socket)&.io&.close
+        rescue IOError, SystemCallError
+          nil
+        end
+      end
+    end
+
+    # A connection that never opened: no byte of the request left this machine.
+    NEVER_OPENED = [Errno::ECONNREFUSED, Errno::ENOENT, Errno::EHOSTUNREACH, Errno::ENETUNREACH,
+                    Errno::EADDRNOTAVAIL].freeze
+
+    # Whether a failure, or one of its causes, is a connection that never
+    # opened. A timeout or a reset never counts.
+    def self.never_sent?(error)
+      at = error
+      5.times do
+        return false if at.nil?
+        return true if NEVER_OPENED.any? { |kind| at.is_a?(kind) }
+
+        at = at.cause
+      end
+      false
+    end
+
     def backoff(attempt) = [8.0, 0.25 * (2**[attempt, 10].min)].min * (0.5 + rand)
 
     # 0.5 s, 1 s, 2 s, 4 s, then every 8 s, jittered, so a queue of CI jobs spreads out.
@@ -262,6 +383,8 @@ module WithRuntime
       room_attempt = 0
       payload = raw || (body.nil? ? nil : JSON.generate(body))
       attempt = 0
+      # The last try never left, and was sent again at once.
+      resent_at_once = false
       loop do
         raise connection_error(true, write, key) if cancel&.cancelled?
         left = deadline - now
@@ -278,9 +401,22 @@ module WithRuntime
           request["Content-Type"] = raw ? "application/octet-stream" : "application/json"
           request.body = payload
         end
-        http.read_timeout = left
+        # Until its answer starts, a read waits at most answer_start; then the
+        # call's whole deadline again.
+        bounded = Transport.answer_start < left
+        answered = false
+        http.read_timeout = bounded ? Transport.answer_start : left
         http.write_timeout = left if http.respond_to?(:write_timeout=)
+        http.open_timeout = [left, 30].min
+        # Per-read limits do not bound a body that keeps trickling in: at the
+        # deadline the socket is closed, and the read fails as a timeout.
+        watchdog = deadline_watchdog(http, left)
         response = nil
+        # A stream that gave its consumer anything is never sent again: that
+        # would give the same events twice. The consumer's own errors are its
+        # own, never a reason to retry.
+        streamed = false
+        consumer_error = nil
         begin
           open_connection(http, cancel)
           cancel&.register do
@@ -296,11 +432,27 @@ module WithRuntime
           raise connection_error(true, write, key) if cancel&.cancelled?
           if stream
             http.request(request) do |answer|
+              answered = true
+              http.read_timeout = [deadline - now, 0.001].max
               response = answer
-              answer.read_body(&stream) if answer.code.to_i < 300
+              # A late answer is read whole first: it may be a failure.
+              if answer.code.to_i < 300 && answer["runtime-late-answer"] != "true"
+                answer.read_body do |chunk|
+                  streamed = true
+                  begin
+                    stream.call(chunk)
+                  rescue Exception => e
+                    consumer_error = e
+                    raise
+                  end
+                end
+              end
             end
           else
-            response = http.request(request)
+            response = http.request(request) do
+              answered = true
+              http.read_timeout = [deadline - now, 0.001].max
+            end
           end
           status = response.code.to_i
           if status >= 300 && status < 400
@@ -308,14 +460,35 @@ module WithRuntime
           end
         rescue *NETWORK_ERRORS => e
           http.finish if http.started?
-          late = e.is_a?(Timeout::Error) || now >= deadline || cancel&.cancelled?
-          raise connection_error(late, write, key, e) if late || no_retry || attempt >= max_retries
+          raise if e.equal?(consumer_error)
 
-          pause(backoff(attempt), deadline, write, key, nil, cancel)
+          unanswered = bounded && !answered && e.is_a?(Net::ReadTimeout) && now < deadline
+          late = (e.is_a?(Timeout::Error) && !unanswered) || now >= deadline || cancel&.cancelled?
+          raise connection_error(late, write, key, e) if late || no_retry || streamed || attempt >= max_retries
+
+          # A connection that never opened sent no byte of the request, so the
+          # next try, which may reach another server, goes at once; once in a
+          # row, so an API that is down is not hammered. A reset or a timeout
+          # may have reached a server and keeps the backoff and its key's rules.
+          at_once = Transport.never_sent?(e) && !resent_at_once
+          resent_at_once = at_once
+          pause(at_once ? rand * 0.05 : backoff(attempt), deadline, write, key, nil, cancel)
           attempt += 1
           next
+        ensure
+          watchdog.kill
+        end
+        # An answer that took longer than the API holds its headers (90 s)
+        # comes as a 200 sent early, and then its JSON: the answer, or
+        # {"error": ...} when the work failed after the status went
+        # (runtime-late-answer). A failure is raised as the error it is,
+        # never returned as a success.
+        late = status < 300 && response["runtime-late-answer"] == "true"
+        status = Transport.late_failure(response.body.to_s) if late
+        if status < 300
+          stream&.call(response.body.to_s) if late
+          return response
         end
-        return response if status < 300
 
         text = response.body.to_s
         parsed = begin

data/lib/withruntime/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module WithRuntime
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/withruntime/wallet.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module WithRuntime
+  # An account opened with a wallet alone: no key, no sign-in, no browser.
+  #
+  #   opened = WithRuntime::Wallet.open_account(20, accept_terms: true)
+  #   # send exactly opened["amount"] to one of opened["networks"], then, once paid:
+  #   key = WithRuntime::Wallet.claim_account(opened["claimCode"])["apiKey"]
+  #
+  # Opening one means agreeing to https://withruntime.com/legal/terms, so ask the
+  # person you work for first. The claim code is shown once and is the only way
+  # to the account's key: keep it secret. These two calls go to the website;
+  # every call after the key goes to the API as usual.
+  module Wallet
+    module_function
+
+    # Opens an account and a stablecoin top-up of +usd+ dollars ($10 to
+    # $500: it is a new account's first week). Returns "claimCode", "amount" (the exact token amount, to six
+    # decimals), "networks" (an "address" on each and its "tokens") and "payBy".
+    def open_account(usd, accept_terms:, auth_url: nil, timeout: 30)
+      post(auth_url, "/api/wallet/topups", { "usd" => usd, "acceptTerms" => accept_terms }, timeout)
+    end
+
+    # Once the top-up is paid, {"status" => "paid", "apiKey" => ...}, once.
+    # Before that, the top-up's "status"; call again.
+    def claim_account(claim_code, auth_url: nil, timeout: 30)
+      post(auth_url, "/api/wallet/claim", { "claimCode" => claim_code }, timeout)
+    end
+
+    def origin(auth_url)
+      value = auth_url.to_s.empty? ? ENV["RUNTIME_AUTH_URL"].to_s : auth_url
+      (value.empty? ? "https://withruntime.com" : value).chomp("/")
+    end
+
+    # One POST, never redirected, with no Authorization header.
+    def post(auth_url, path, body, timeout)
+      base = origin(auth_url)
+      uri = URI("#{base}#{path}")
+      http = Net::HTTP.new(uri.host, uri.port, nil)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = http.read_timeout = http.write_timeout = timeout
+      request = Net::HTTP::Post.new(uri.request_uri, "Content-Type" => "application/json")
+      request.body = JSON.generate(body)
+      answer = begin
+        http.start { |connection| connection.request(request) }
+      rescue *Transport::NETWORK_ERRORS
+        raise Error.new("No answer from #{base}.", code: "network", hint: "Retry in a minute.")
+      end
+      said = begin
+        JSON.parse(answer.body.to_s)
+      rescue JSON::ParserError
+        nil
+      end
+      said = {} unless said.is_a?(Hash)
+      status = answer.code.to_i
+      return said if status.between?(200, 299)
+
+      raise Error.new(said["error"].is_a?(String) ? said["error"] : "The request failed (HTTP #{status}).",
+                      code: said["code"].is_a?(String) ? said["code"] : (status == 429 ? "rate_limited" : "request_failed"),
+                      status: status)
+    end
+    private_class_method :origin, :post
+  end
+end

data/lib/withruntime.rb

@@ -6,8 +6,9 @@
 #   require "withruntime"
 #
 #   runtime = WithRuntime::Client.new # RUNTIME_API_KEY, or this machine's saved connection
-#   sbx = runtime.sandboxes.create(funding: "trial")
-#   puts sbx.exec("python3 -c 'print(6 * 7)'", check: true).stdout
+#   sbx = runtime.sandboxes.create
+#   sbx.files.write("/workspace/invoice.py", "print(sum([125, 250, 375]))\n")
+#   puts sbx.exec("python3 /workspace/invoice.py", check: true).stdout
 #   sbx.stop
 #
 # The guide is at https://withruntime.com/docs/ruby.
@@ -16,10 +17,12 @@ require "openssl"
 
 require_relative "withruntime/version"
 require_relative "withruntime/errors"
+require_relative "withruntime/api_defaults"
 require_relative "withruntime/record"
 require_relative "withruntime/fields"
 require_relative "withruntime/transport"
 require_relative "withruntime/credentials"
+require_relative "withruntime/wallet"
 require_relative "withruntime/tar"
 require_relative "withruntime/sandbox"
 require_relative "withruntime/products"