sandbox-provider 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 012300e69a3b0389101f1d843340008aab5e7cc0ef0173227187e7a0f889ec52
+  data.tar.gz: 10e39f638d1aec981f651a0ed391a07834fbb0a900944ae8ddcff6996a726cea
+SHA512:
+  metadata.gz: 12d574beb0f49b05519c9ff95fae5de37d5c54baf0fa034b1d0d64d138e99d6925531ea48d449e02d7ca4adbfe4a7d64597067a750e73b57a358de96388d66e5
+  data.tar.gz: 7370726a28469cf76d5d55d55a20fc226928bea484e9739be9cba51f6e88bc32ab0b75b4787f6ce421f8486bd2ee22d27fcd1c354e78a434885c7c5436286f4d

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nvoi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+# sandbox-provider
+
+Providers for `sandbox-adapter`.
+
+| Name | Class | Kind |
+|---|---|---|
+| daytona | `Sandbox::Provider::Daytona` | sandbox, forks from a seed snapshot, SSH |
+| boat_dev | `Sandbox::Provider::BoatDev` | sandbox, SSH, named snapshots |
+| e2b | `Sandbox::Provider::E2b` | sandbox, envd transport |
+| hetzner | `Sandbox::Provider::Hetzner` | full VM, cloud-init |
+
+```ruby
+require "sandbox-provider"
+
+Sandbox::Adapter.providers = {
+  "daytona" => "Sandbox::Provider::Daytona",
+  "e2b" => "Sandbox::Provider::E2b"
+}
+```
+
+Keys: `DAYTONA_API_KEY`, `E2B_API_KEY`, `BOAT_DEV_API_KEY`, `HETZNER_API_KEY`. Settings: `daytona_org_id`, `boat_dev_team_id`.

data/lib/sandbox/provider/boat_dev/client.rb

@@ -0,0 +1,75 @@
+require "net/http"
+
+# Thin JSON client for https://boat.dev/api/v1. Raises Sandbox::Adapter::Provider::Error on non-2xx; 404 reads as nil
+# where a lookup is meant. Every body comes back symbol-keyed. `org` is the team whose wallet pays, sent as
+# X-Boat-Org on every request; without one the key's own account pays.
+class Sandbox::Provider::BoatDev::Client
+  BASE = "https://boat.dev/api/v1"
+  RETRIED = [ 429, 502, 503, 504 ].freeze
+
+  def initialize(token, org: nil)
+    @token = token
+    @org = org
+  end
+
+  def get(path, params = {}) = request(Net::HTTP::Get, path, params:)
+  def post(path, body = {}, again: true, headers: {})
+    request(Net::HTTP::Post, path, body:, again:, headers:)
+  end
+  def patch(path, body = {}) = request(Net::HTTP::Patch, path, body:)
+  def delete(path, headers: {}) = request(Net::HTTP::Delete, path, headers:)
+
+  # nil when the resource is not there.
+  def find(path)
+    get(path)
+  rescue Sandbox::Adapter::Provider::Error => e
+    raise unless e.status == 404
+    nil
+  end
+
+  private
+
+    def request(klass, path, params: {}, body: nil, headers: {}, again: true)
+      uri = URI("#{BASE}#{path}")
+      uri.query = URI.encode_www_form(params) if params.any?
+      attempts = 0
+      loop do
+        attempts += 1
+        req = klass.new(uri)
+        req["Authorization"] = "Bearer #{@token}"
+        req["Content-Type"] = "application/json"
+        req["X-Boat-Org"] = @org if @org.present?
+        headers.each { |k, v| req[k] = v }
+        req.body = body.to_json if body
+        res = Sandbox::Adapter::Provider.reaching("boat.dev") do
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 120) do |http|
+            http.request(req)
+          end
+        end
+        json = res.body.to_s.empty? ? {} : parse(res.body)
+        return json if res.is_a?(Net::HTTPSuccess)
+
+        code = res.code.to_i
+        if again && RETRIED.include?(code) && attempts < 4
+          sleep attempts * 0.5
+          next
+        end
+        raise Sandbox::Adapter::Provider::Error.new(
+          "boat.dev #{req.method} #{path} #{code}: #{detail(json)}",
+          status: code
+        )
+      end
+    end
+
+    # Their envelope carries a code and a message; a body that is not JSON is kept as text.
+    def detail(json)
+      return json.to_s[0, 200] unless json.is_a?(Hash)
+      [ json[:code], json[:message] ].compact.join(" ")
+    end
+
+    def parse(body)
+      JSON.parse(body, symbolize_names: true)
+    rescue JSON::ParserError
+      body
+    end
+end

data/lib/sandbox/provider/boat_dev/key.rb

@@ -0,0 +1,30 @@
+require "ed25519"
+
+# The one SSH key pair the app presents to boat.dev sandboxes: ed25519, derived from the app's secret, so every
+# process holds the same key and a sandbox authorises it once. Net::SSH reads the private half in OpenSSH's
+# own format, built here since OpenSSL cannot write it.
+module Sandbox::Provider::BoatDev::Key
+  COMMENT = "nvoi"
+
+  def self.private_key = @private_key ||= openssh(seed)
+  def self.public_key = ::SshKey.public_key(private_key)
+
+  def self.seed = Sandbox::Adapter.credentials.key("boat_dev_ssh", length: 32)
+
+  # An unencrypted openssh-key-v1 envelope around the seed and its public half.
+  def self.openssh(seed)
+    signing = Ed25519::SigningKey.new(seed)
+    pk = signing.verify_key.to_bytes
+    public_blob = field("ssh-ed25519") + field(pk)
+    check = SecureRandom.bytes(4)
+    private_blob = check + check + field("ssh-ed25519") + field(pk) + field(seed + pk) +
+                   field(COMMENT)
+    private_blob << (1..(8 - private_blob.bytesize % 8) % 8).to_a.pack("C*")
+    blob = "openssh-key-v1\0".b + field("none") + field("none") + field("") + [ 1 ].pack("N") +
+           field(public_blob) + field(private_blob)
+    lines = Base64.strict_encode64(blob).scan(/.{1,70}/).join("\n")
+    "-----BEGIN OPENSSH PRIVATE KEY-----\n#{lines}\n-----END OPENSSH PRIVATE KEY-----\n"
+  end
+
+  def self.field(bytes) = [ bytes.bytesize ].pack("N") + bytes.b
+end

data/lib/sandbox/provider/boat_dev.rb

@@ -0,0 +1,380 @@
+# boat.dev sandboxes: Ubuntu VMs from their own image, named through the display name (they keep no labels).
+# A sealed seed is a named snapshot, deployable by name across the account and independent of the machine
+# it was taken from; a fork is a sandbox created from it. SSH lands as `user`, who has sudo, behind the
+# app's key.
+class Sandbox::Provider::BoatDev < Sandbox::Adapter::SandboxVm
+  # Seconds before boat.dev archives a sandbox, counted from its last create, resume or refresh (they have no
+  # idle timer): the net for a dead control plane, refreshed with every transport. The app's own IdleJob
+  # parks boxes long before. Two hours is the most a trial account may set.
+  TIMEOUT = 2 * 3600
+  # A sealed seed's id, as machines carry it: `snapshot:<name>`. Named snapshots are the account's, read,
+  # deployed and deleted by name; the machine they were taken from is kept beside them, stopped, so the
+  # seed is still found by its name.
+  SNAPSHOT = "snapshot:"
+  # By the state string the API answers; the rest is on its way up.
+  STATES = {
+    "ready" => :running,
+    "idle" => :running,
+    "running" => :running,
+    "archiving" => :stopped,
+    "archived" => :stopped,
+    "error" => :broken
+  }.freeze
+  ACTIVE = %w[ready idle running].freeze
+  SETTLED = (ACTIVE + %w[archived error]).freeze
+  LOGIN = "user"
+  # What a snapshot carries: /home/user, /etc, /usr, /opt, /var/lib; not /mnt. The data lives in the home.
+  MOUNT = "/home/user/nvoi"
+  # A fork copies the parent's latest snapshot, taken about once a minute while it runs: a fork waits this
+  # long for one newer than the request, then goes with what there is.
+  SNAPSHOT_WAIT = 150
+  ACCESS_MINUTES = 5
+  # Where SSH lands and the host key their API vouches for, good until `until`. A resume is a new machine
+  # with a new key, so nothing outlives a wake.
+  Access = Data.define(:host, :port, :host_key, :until)
+  ACCESS = {}
+  ACCESS_LOCK = Mutex.new
+
+  # The team whose wallet pays, when there is one.
+  def self.team_id
+    Sandbox::Adapter.credentials.setting(:boat_dev_team_id)
+  end
+
+  def initialize(token, team_id: self.class.team_id, client: Client.new(token, org: team_id), **)
+    super(token, **)
+    @client = client
+  end
+
+  # The login is the deploy user: nothing runs as root, sudo does the rest.
+  def layout = Sandbox::Adapter::Layout.for(login: LOGIN, volume: false).with(user: LOGIN, mount: MOUNT)
+
+  # Their image is what sandboxes come from; nothing to make.
+  def prepare(shape = default_shape, disk = default_disk(shape)) = nil
+
+  # Their sizes, disk fixed by the tier, at the table's price. small is the shape every sandbox gets today.
+  TIERS = {
+    "2x4" => [ "small", 12 ],
+    "4x8" => [ "default", 50 ],
+    "8x16" => [ "large", 125 ],
+    "16x32" => [ "xlarge", 251 ]
+  }.freeze
+
+  def shapes
+    as_of = price_table.as_of("boat_dev")
+    TIERS.to_h do |key, (type, disk)|
+      cpu, memory = key.split("x").map(&:to_i)
+      [ key, Sandbox::Adapter.shape(cpu:, memory:, disk:, type:, rate: price_table.cents("boat_dev", type),
+                           source: :table, as_of:) ]
+    end
+  end
+
+  PRICING = "https://docs.boat.dev/pricing".freeze
+
+  # Their pricing page, markdown: a table row per type, its $/hour in bold.
+  def prices(page = Sandbox::Adapter::Pages.fetch(PRICING))
+    rates = TIERS.to_h do |_, (type, _)|
+      dollars = page[/`#{type}`[^$\n]{0,40}\$(\d+\.\d+)/,
+1] or return { source: "page", rates: nil }
+      [ type, Sandbox::Adapter::Pages.cents(dollars) ]
+    end
+    { source: "page", rates: }
+  end
+
+  # Their meter since creation. The billed seconds carry the type's multiplier; wall seconds are those
+  # divided back. A snapshot has no meter.
+  def usage(m)
+    return nil if snapshot?(m)
+    usage = @client.get("/sandboxes/#{m.id}/usage")
+    multiplier = usage[:billingMultiplier].to_f.nonzero? || 1.0
+    { seconds: (usage[:seconds].to_f / multiplier).round,
+cents: (usage[:dollars].to_f * 100).round(6) }
+  end
+
+  # Every sandbox of the account, newest first.
+  def list
+    machines = []
+    cursor = nil
+    loop do
+      page = @client.get("/sandboxes", { limit: 200, cursor: }.compact)
+      machines.concat(page[:sandboxes].map { machine(_1) })
+      cursor = page.dig(:pageInfo, :nextCursor)
+      return machines if cursor.blank?
+    end
+  end
+
+  # Retried safely: the name and the request are the idempotency key, so a lost answer does not make a
+  # second sandbox, and the same name asked differently later is a new request. noEnv keeps the account's
+  # secrets out of it.
+  def create(name, labels: {}, shape: default_shape, disk: default_disk(shape), from: nil, **)
+    body = { type: TIERS.fetch(shape).first, ttlSeconds: TIMEOUT, noEnv: true, from: }.compact
+    key = "nvoi-#{Digest::SHA256.hexdigest("#{name}\n#{body.to_json}")[0, 32]}"
+    sandbox = lookup(name) || named(
+      @client.post("/sandboxes", body, headers: { "Idempotency-Key" => key })[:sandbox],
+      name
+    )
+    wake(machine(sandbox))
+  end
+
+  # A name is a sandbox's; a sealed seed's sandbox stays, stopped, as the snapshot's source, so the seed
+  # is found through it.
+  def find(name)
+    saved = snapshot(snapshot_name(name))
+    return snapshot_machine(snapshot_name(name), saved) if saved
+    sandbox = lookup(name) or return nil
+    machine(sandbox)
+  end
+
+  # The seed's machine becomes a named snapshot of it, and the machine is stopped: forks deploy the
+  # snapshot by name, nothing has to keep running for them.
+  def seal(m)
+    name = snapshot_name(m.name)
+    @client.post("/named-snapshots", { sandboxId: m.id, name: })
+    saved = wait_snapshot(name)
+    @client.post("/sandboxes/#{m.id}/stop", {}, again: false)
+    snapshot_machine(name, saved)
+  end
+
+  # A snapshot is always ready; a sandbox archived is resumed.
+  def wake(m)
+    return m if snapshot?(m)
+    current = wait(m.id) { |s| SETTLED.include?(s) }
+    if current[:state] == "archived"
+      @client.post("/sandboxes/#{m.id}/resume", { ttlSeconds: TIMEOUT }, again: false)
+      ACCESS_LOCK.synchronize { ACCESS.delete(m.id) }
+      current = wait(m.id) { |s| ACTIVE.include?(s) || s == "error" }
+    end
+    unless ACTIVE.include?(current[:state])
+      raise Error, "sandbox #{m.name} #{current[:state]}: #{current[:error]}"
+    end
+    machine(current)
+  end
+
+  # A stop saves the disk first, in the background; the answer is whether there is still a machine to wake.
+  # A snapshot has nothing to stop.
+  def halt(m)
+    return true if snapshot?(m)
+    ACCESS_LOCK.synchronize { ACCESS.delete(m.id) }
+    sandbox = @client.find("/sandboxes/#{m.id}")&.dig(:sandbox)
+    return false if sandbox.nil?
+    unless %w[archived archiving].include?(sandbox[:state])
+      @client.post("/sandboxes/#{m.id}/stop")
+    end
+    true
+  end
+
+  # A sandbox: force-stopped and gone, along with its own snapshots. A sealed seed: the named snapshot,
+  # and the stopped machine it was taken from when it is still there. Gone already is fine.
+  def destroy(m)
+    ACCESS_LOCK.synchronize { ACCESS.delete(m.id) }
+    if snapshot?(m)
+      name = snapshot_ref(m)
+      saved = snapshot(name)
+      if saved
+        @client.delete("/named-snapshots/#{name}", headers: { "X-Ascii-Confirm-Delete" => name })
+        source = @client.find("/sandboxes/#{saved[:sourceSandboxId]}")&.dig(:sandbox)
+        destroy(machine(source)) if source
+      end
+    else
+      @client.delete("/sandboxes/#{m.id}", headers: { "X-Ascii-Confirm-Delete" => m.id })
+    end
+  rescue Error => e
+    raise unless e.status == 404
+  end
+
+  # A sandbox from the sealed seed's snapshot: its disk as sealed, up in seconds. A name already taken is
+  # the one from a previous attempt. Labels have nowhere to go.
+  def fork(m, name, labels: {}, shape: nil, disk: nil)
+    raise Error, "#{m.name} is not a sealed seed" unless snapshot?(m)
+    m = Sandbox::Adapter::Machine.new(id: m.id, name: m.name, state: m.state,
+data: m.data.merge({ shape:, disk: }.compact))
+    create(name, from: snapshot_ref(m), shape: m.data[:shape] || default_shape,
+disk: m.data[:disk] || default_disk(m.data[:shape] || default_shape))
+  end
+
+  # SSH as `user` with the app's key, at the endpoint their API answers along with the machine's host key,
+  # which is the pin: a resume lands on a new machine, so a key kept from before would only mismatch.
+  # Access is kept per process, and another process may have paused or resumed the sandbox since: a key
+  # that no longer matches, or an endpoint that no longer answers, is asked of their API again.
+  def transport(m, key: nil, host_key: nil, on_host_key: nil)
+    ssh = lambda do |fresh|
+      access = ACCESS_LOCK.synchronize do
+        kept = ACCESS[m.id]
+        kept = nil if fresh || kept.nil? || kept.until < Time.current
+        kept || (ACCESS[m.id] = mint(m.id))
+      end
+      Sandbox::Adapter::Ssh.new(
+        host: access.host,
+        port: access.port,
+        user: LOGIN,
+        key: Key.private_key,
+        host_key: access.host_key || (host_key unless fresh),
+        on_host_key: (on_host_key unless access.host_key)
+      )
+    end
+    Repinning.new(ssh)
+  end
+
+  # An SSH transport that asks for the sandbox's current access when the one it holds fails: a pinned key
+  # that no longer matches (raised on connect, before any command runs) is retried at once on the fresh
+  # access; a refused or dropped connection is raised as it was, for the caller's own retry to use the fresh
+  # access. Access is asked again at most every AGAIN seconds.
+  class Repinning < SimpleDelegator
+    AGAIN = 10
+
+    def initialize(ssh)
+      @ssh = ssh
+      super(ssh.call(false))
+    end
+
+    def exec(...) = again { __getobj__.exec(...) }
+    def upload(...) = again { __getobj__.upload(...) }
+    def download(...) = again { __getobj__.download(...) }
+
+    private
+
+      def again
+        yield
+      rescue Sandbox::Adapter::Ssh::HostKeyMismatch
+        raise unless refresh
+        yield
+      rescue *Sandbox::Adapter::Ssh::CONNECTION_ERRORS
+        refresh
+        raise
+      end
+
+      def refresh
+        return false if @refreshed && Time.current - @refreshed < AGAIN
+        @refreshed = Time.current
+        __setobj__(@ssh.call(true))
+        true
+      end
+  end
+
+  # Their stable route for the port, TLS at their edge, opened ungated: the gate they offer is a `_token`
+  # query parameter that turns into a cookie, which the worker cannot set without dropping the visitor's
+  # own. Idempotent, so it is asked on every call. A parked sandbox is nothing to proxy to.
+  def preview(m, port)
+    sandbox = @client.find("/sandboxes/#{m.id}")&.dig(:sandbox) or return nil
+    return nil unless ACTIVE.include?(sandbox[:state])
+
+    # Private at their edge: the url carries a token their edge takes once as `?_token=` and then wants
+    # as a `_port_auth` cookie; the worker sends the cookie on every request. No header form exists.
+    hosted = @client.post("/sandboxes/#{m.id}/host", { port:, public: false })
+    uri = URI(hosted[:url].to_s)
+    raise Error, "sandbox #{m.id} answered no url for port #{port}" if uri.host.blank?
+    token = URI.decode_www_form(uri.query.to_s).to_h["_token"]
+    raise Error, "sandbox #{m.id} answered no token for port #{port}" if token.blank?
+    {
+      host: [ uri.host, (uri.port unless uri.port == uri.default_port) ].compact.join(":"),
+      scheme: uri.scheme,
+      token:,
+      headers: { "cookie" => "_port_auth=#{token}" }
+    }
+  rescue Error => e
+    raise unless e.status == 400 && e.message.include?("machine_not_running")
+    nil
+  end
+
+  private
+
+    # The sandbox of ours by that name, newest first; the list has no filter of its own.
+    def lookup(name)
+      cursor = nil
+      loop do
+        page = @client.get("/sandboxes", { limit: 200, cursor: }.compact)
+        found = page[:sandboxes].find { |s| s[:name] == name }
+        return found if found
+        cursor = page.dig(:pageInfo, :nextCursor)
+        return nil if cursor.blank?
+      end
+    end
+
+    def named(sandbox, name)
+      @client.patch("/sandboxes/#{sandbox[:id]}", { name: })[:sandbox]
+    end
+
+    # Authorises the key and refreshes the deadline; asked again while the machine is still coming up.
+    def mint(id)
+      deadline = Time.current + 60
+      begin
+        access = @client.post("/sandboxes/#{id}/sshkey", { key: Key.public_key })
+      rescue Error => e
+        raise unless e.status == 409 && Time.current < deadline
+        sleep 2
+        retry
+      end
+      @client.patch("/sandboxes/#{id}", { ttlSeconds: TIMEOUT })
+      host, port = access[:sshEndpoint].presence&.split(":") || [ access[:machineIp], 22 ]
+      raise Error, "sandbox #{id} has no address" if host.blank?
+      Access.new(
+        host:,
+        port: port.to_i,
+        host_key: access[:hostKey].presence,
+        until: Time.current + ACCESS_MINUTES.minutes
+      )
+    end
+
+    # Named snapshots are the account's; the name is the seed's, within their alphabet.
+    def snapshot_name(seed_name) = seed_name.downcase.gsub(/[^a-z0-9-]/, "-")[0, 63]
+    def snapshot?(m) = m.id.to_s.start_with?(SNAPSHOT)
+    def snapshot_ref(m) = m.id.delete_prefix(SNAPSHOT)
+
+    def snapshot(name)
+      @client.find("/named-snapshots/#{name}")&.dig(:snapshot)
+    end
+
+    def snapshot_machine(name, saved)
+      state = { "ready" => :running, "saving" => :starting }.fetch(saved[:status], :broken)
+      Sandbox::Adapter::Machine.new(id: "#{SNAPSHOT}#{name}", name:, state:,
+data: { source: saved[:sourceSandboxId] })
+    end
+
+    # Saving takes as long as the disk; a snapshot that failed says why.
+    def wait_snapshot(name)
+      deadline = Time.current + SNAPSHOT_WAIT
+      loop do
+        saved = snapshot(name) or raise Error, "snapshot #{name} is gone"
+        return saved if saved[:status] == "ready"
+        raise Error, "snapshot #{name} failed: #{saved[:error]}" if saved[:status] == "failed"
+        raise Error,
+"snapshot #{name} still saving after #{SNAPSHOT_WAIT}s" if Time.current > deadline
+        sleep 3
+      end
+    end
+
+    # A snapshot newer than now, when the parent is up: what a fork copies is the latest one, and the parent
+    # may have written since. A stopped parent's final snapshot is complete already.
+    def snapshotted(id)
+      asked = Time.current
+      deadline = asked + SNAPSHOT_WAIT
+      loop do
+        sandbox = @client.get("/sandboxes/#{id}")[:sandbox]
+        return unless ACTIVE.include?(sandbox[:state])
+        taken = sandbox[:snapshotCompletedAt]
+        return if taken && Time.parse(taken) >= asked
+        return if Time.current > deadline
+        sleep 5
+      end
+    end
+
+    def wait(id, timeout: 300)
+      deadline = Time.current + timeout
+      loop do
+        sandbox = @client.get("/sandboxes/#{id}")[:sandbox]
+        return sandbox if yield(sandbox[:state])
+        if Time.current > deadline
+          raise Error, "sandbox #{id} still #{sandbox[:state]} after #{timeout}s"
+        end
+        sleep 2
+      end
+    end
+
+    def machine(sandbox)
+      Sandbox::Adapter::Machine.new(
+        id: sandbox[:id],
+        name: sandbox[:name],
+        state: STATES.fetch(sandbox[:state], :starting),
+        data: sandbox
+      )
+    end
+end

data/lib/sandbox/provider/cloud_init.rb

@@ -0,0 +1,19 @@
+# Boot config for a new server: one sudoer, key-only SSH, root disabled. Docker is installed later over SSH.
+module Sandbox::Provider::CloudInit
+  def self.render(hostname:, user:, public_key:)
+    {
+      hostname:,
+      users: [
+        {
+          name: user,
+          groups: [ "sudo" ],
+          shell: "/bin/bash",
+          sudo: "ALL=(ALL) NOPASSWD:ALL",
+          ssh_authorized_keys: [ public_key ]
+        }
+      ],
+      ssh_pwauth: false,
+      disable_root: true
+    }.deep_stringify_keys.to_yaml(line_width: -1).sub("---\n", "#cloud-config\n")
+  end
+end

data/lib/sandbox/provider/daytona/client.rb

@@ -0,0 +1,70 @@
+require "net/http"
+
+# Thin JSON client for https://app.daytona.io/api. Raises Sandbox::Adapter::Provider::Error on non-2xx; 404 reads as nil
+# where a lookup is meant. Every body comes back symbol-keyed.
+class Sandbox::Provider::Daytona::Client
+  BASE = "https://app.daytona.io/api"
+  ANALYTICS = "https://analytics.app.daytona.io"
+  RETRIED = [ 429, 502, 503, 504 ].freeze
+
+  def initialize(token)
+    @token = token
+  end
+
+  def get(path, params = {}) = request(Net::HTTP::Get, path, params:)
+  def post(path, body = {}, params: {}, again: true)
+    request(Net::HTTP::Post, path, body:, params:, again:)
+  end
+  def put(path, body = {}) = request(Net::HTTP::Put, path, body:)
+  def delete(path, params = {}) = request(Net::HTTP::Delete, path, params:)
+  # The analytics API, same key: usage periods per sandbox.
+  def analytics(path, params = {}) = request(Net::HTTP::Get, path, params:, base: ANALYTICS)
+
+  # nil when the resource is not there.
+  def find(path)
+    get(path)
+  rescue Sandbox::Adapter::Provider::Error => e
+    raise unless e.status == 404
+    nil
+  end
+
+  private
+
+    def request(klass, path, params: {}, body: nil, again: true, base: BASE)
+      uri = URI("#{base}#{path}")
+      uri.query = URI.encode_www_form(params) if params.any?
+      attempts = 0
+      loop do
+        attempts += 1
+        req = klass.new(uri)
+        req["Authorization"] = "Bearer #{@token}"
+        req["Content-Type"] = "application/json"
+        req.body = body.to_json if body
+        res = Sandbox::Adapter::Provider.reaching("daytona") do
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, read_timeout: 120) do |http|
+            http.request(req)
+          end
+        end
+        json = res.body.to_s.empty? ? {} : parse(res.body)
+        return json if res.is_a?(Net::HTTPSuccess)
+
+        code = res.code.to_i
+        if again && RETRIED.include?(code) && attempts < 4
+          sleep attempts * 0.5
+          next
+        end
+        detail = json.is_a?(Hash) ? json[:message] : json.to_s[0, 200]
+        raise Sandbox::Adapter::Provider::Error.new(
+          "daytona #{req.method} #{path} #{code}: #{detail}",
+          status: code
+        )
+      end
+    end
+
+    # Symbol-keyed; a body that is not JSON is kept as text for the error.
+    def parse(body)
+      JSON.parse(body, symbolize_names: true)
+    rescue JSON::ParserError
+      body
+    end
+end