pinesandbox 0.3.19 → 0.3.20

data/lib/pinesandbox/attach_credentials_source.rb

@@ -1,5 +1,6 @@
 require "faraday"
 require "json"
+require "time"
 require_relative "errors"
 
 module PineSandbox
@@ -18,6 +19,8 @@ module PineSandbox
   #     advances the key floor, supersedes the prior binding, and mints.
   #   * DELETE /v1/computers/:computer_id                 — permanent delete.
   #     204 for deleted, already deleted, unknown, and cross-project ids alike.
+  #   * POST /v1/computers/:computer_id/artifacts/token   — a short-lived
+  #     storage token for the Computer's artifacts (Artifacts).
   #
   # This source caches nothing. Computer#run_bind calls it exactly once for each
   # start, then convergence retries re-send the held envelope verbatim
@@ -97,6 +100,30 @@ module PineSandbox
       payload
     end
 
+    # A short-lived storage token for the Computer's artifacts, and where they
+    # are: "access_token", "expires_at", "endpoint", "bucket", "prefix",
+    # "writable", "used_bytes" and "limit_bytes". With `copy_from` (other
+    # Computer ids of the project), it may also read their artifacts, and
+    # "copy_from" maps each id to its prefix. Works whether or not the
+    # Computer is running. Returns the response Hash.
+    def artifact_token(computer_id, copy_from: nil)
+      raise ArgumentError, "computer_id required" if computer_id.to_s.empty?
+
+      copy_from = Array(copy_from).map(&:to_s)
+      body = copy_from.empty? ? {} : { copy_from: copy_from }
+      resp = post("#{REGISTER_PATH}/#{computer_id}/artifacts/token", json: body, op: "artifact token")
+      if resp.status == 404
+        raise UnknownComputerError.new(error_message(resp, "Computer not found"), **error_attributes(resp))
+      end
+      raise PortalError.new(error_message(resp, "Artifact token unavailable"), **error_attributes(resp)) unless resp.status == 200
+
+      payload = parse_json(resp)
+      unless artifact_token?(payload, copy_from)
+        raise PortalError.new("Invalid artifact token response", **error_attributes(resp))
+      end
+      payload
+    end
+
     # One authorization-registry read before Start; never a Computer status poll.
     def current_binding(computer_id)
       resp = get("#{REGISTER_PATH}/#{computer_id}", op: "computer binding lookup")
@@ -114,7 +141,7 @@ module PineSandbox
 
     # Permanently delete `computer_id`. The portal tombstones it at once (no
     # further attach, renewal, or lease refresh), destroys its bound sandboxes
-    # asynchronously, keeps saved browser state for 24 hours before purging it,
+    # asynchronously, keeps saved browser state for 25 hours before purging it,
     # and never accepts the id again. Idempotent and non-disclosing: an unknown,
     # already-deleted, or cross-project id is the same 204. Returns true.
     def delete_computer(computer_id)
@@ -208,12 +235,14 @@ module PineSandbox
         )
       when 412
         problem = parse_json(resp)
+        # A Portal that predates current_revision sends only current_binding_revision.
+        revision = problem.fetch("current_revision") { problem["current_binding_revision"] }
         raise BindingRevisionConflictError.new(
           binding_conflict_message(
             error_message(resp, "binding revision changed; reload and adopt the winning binding"),
-            problem["current_binding_revision"], problem["current_sandbox_id"]
+            revision, problem["current_sandbox_id"]
           ),
-          current_binding_revision: problem["current_binding_revision"],
+          current_binding_revision: revision,
           current_sandbox_id: problem["current_sandbox_id"],
           **error_attributes(resp)
         )
@@ -243,6 +272,19 @@ module PineSandbox
       { country: normalized.fetch("country") }
     end
 
+    def artifact_token?(payload, copy_from)
+      return false unless payload.is_a?(Hash)
+      return false unless %w[access_token expires_at endpoint bucket].all? { |key| payload[key].is_a?(String) && !payload[key].empty? }
+      return false unless payload["prefix"].is_a?(String) && [true, false].include?(payload["writable"])
+      return false unless payload["used_bytes"].is_a?(Integer) && payload["limit_bytes"].is_a?(Integer)
+
+      Time.iso8601(payload["expires_at"])
+      prefixes = payload["copy_from"] || {}
+      prefixes.is_a?(Hash) && copy_from.all? { |id| prefixes[id].is_a?(String) }
+    rescue ArgumentError
+      false
+    end
+
     def response_location?(value)
       value.is_a?(Hash) && value["country"].is_a?(String) &&
         value["country"].match?(/\A[A-Z]{2}\z/)

data/lib/pinesandbox/client.rb

@@ -7,6 +7,7 @@ require_relative "control_plane"
 require_relative "connection"
 require_relative "computer"
 require_relative "diagnostics"
+require_relative "artifacts"
 
 module PineSandbox
   # The SDK entry point. Holds the project credential (`pk_`) + the endpoint
@@ -107,6 +108,7 @@ module PineSandbox
           PineSandbox::Zone.new(endpoint, control_host: control_host, gateway_url: gateway_url)
         end
       @spec_version = spec_version
+      @clock = clock
       @diagnostics = Diagnostics.new(api_key: api_key, zone: @zone) unless api_key.to_s.empty?
 
       token_source =
@@ -184,12 +186,25 @@ module PineSandbox
       provider.project_policy
     end
 
+    # A Computer's artifacts, running or stopped: the files it keeps beyond
+    # its sessions, to list, upload, download, open, copy and delete (see
+    # Artifacts). Needs the project API key; no request is sent until the
+    # first operation.
+    def artifacts(computer_id)
+      raise ArgumentError, "id must be a lowercase UUIDv7" unless computer_id.to_s.match?(Computer::UUID_V7)
+
+      provider = @connection.attach_provider
+      raise ArgumentError, "artifacts require a project API key provider" unless provider.respond_to?(:artifact_token)
+
+      Artifacts.new(computer_id: computer_id, token_source: provider, clock: @clock)
+    end
+
     # PERMANENTLY delete a Computer: its identity and saved state end (stop
     # and kill keep both). Accepts a PineSandbox::Computer or its id String. A
     # Computer that is still attached is force-terminated first (#kill — no
     # final capture, the state is being deleted). The portal tombstones the id
     # immediately, destroys any remaining sandboxes asynchronously, purges saved
-    # state after 24 hours, and never accepts the id again. Idempotent: unknown,
+    # state after 25 hours, and never accepts the id again. Idempotent: unknown,
     # already-deleted, and other projects' ids all return true. No undelete.
     def delete_computer(computer)
       computer_id =

data/lib/pinesandbox/computer.rb

@@ -8,6 +8,7 @@ require_relative "bind_hpke"
 require_relative "capture_keypair"
 require_relative "adapters/coordinator_adapter"
 require_relative "adapters/snapshot_adapter"
+require_relative "artifacts"
 require_relative "session"
 
 module PineSandbox
@@ -21,7 +22,7 @@ module PineSandbox
   #
   #   computer = PineSandbox::Computer.new("0190…", key: secret_32_bytes)
   #   computer.attach(connection)
-  #   session  = computer.create_session(browser: true)
+  #   session  = computer.create_session
   #   session.create_tab(url: "https://example.com")
   #   computer.stop
   #
@@ -386,25 +387,36 @@ module PineSandbox
     # friendly adjective-noun-hex name (e.g. "brave-otter-9f3a1c") — read it back
     # off the returned {Session}. `label` is an optional human-meaningful tag,
     # distinct from the addressing name. A duplicate name raises
-    # PineSandbox::ConflictError. The SDK default is `browser: false` (shell
-    # only), unlike the raw API's; pass `browser: true` for a browser.
-    def create_session(name: nil, label: nil, browser: false, blind: false)
+    # PineSandbox::ConflictError. Every session has its own browser window.
+    #
+    # `artifact_access` is what the session's agent may do with the Computer's
+    # artifacts (see Client#artifacts): "none" (the default: nothing, and the
+    # agent isn't told about them), "read_only" (list and read) or
+    # "read_write" (also save and delete files and make public links). A
+    # Symbol works too. Your own access with the project key is the same
+    # either way.
+    def create_session(name: nil, label: nil, artifact_access: nil)
+      unless artifact_access.nil? || ((artifact_access.is_a?(String) || artifact_access.is_a?(Symbol)) &&
+                                      Session::ARTIFACT_ACCESS.include?(artifact_access.to_s))
+        raise ArgumentError, "artifact_access must be one of #{Session::ARTIFACT_ACCESS.join(', ')}"
+      end
+
+      options = { name: name, label: label }
+      options[:artifact_access] = artifact_access.to_s unless artifact_access.nil?
       rebind_on_unauthorized do
-        payload = coordinator!.create_session(
-          token: computer_token, name: name, label: label, browser: browser, blind: blind
-        )
+        payload = coordinator!.create_session(token: computer_token, **options)
         Session.new(parent: self, payload: payload)
       end
     end
 
     # Desktop delegation in one call:
     #   computer.delegate_desktop(name: session.name)
-    # Ensures the named (browser) desktop session exists, then returns its
+    # Ensures the named desktop session exists, then returns its
     # browser-safe {DelegatedConnection} (host + session name + spec major +
     # a fresh short-TTL `dt_`; no `ct_`/`ps_`/JWS). `create: true` (default) creates
     # the session if absent; `create: false` requires it. To refresh the `dt_`
     # before a reconnect, call `session(name).delegate` again (server-side).
-    def delegate_desktop(name:, create: true, browser: true)
+    def delegate_desktop(name:, create: true)
       require_session_name!(name)
       s =
         begin
@@ -412,7 +424,7 @@ module PineSandbox
         rescue PineSandbox::NotFoundError
           raise unless create
 
-          create_session(name: name, browser: browser)
+          create_session(name: name)
         end
       s.delegate
     end
@@ -426,14 +438,15 @@ module PineSandbox
     # Rebuilds a session from the name and token saved when it was created,
     # under this Computer's current binding.
     # No request, session creation or token refresh; authorization is checked
-    # on first use. Metadata remains available through #session(name).
+    # on first use. Metadata remains available through #session(name); the
+    # rebuilt session's #artifact_access is nil, since only the Computer knows it.
     def adopt_session(name, session_token)
       coordinator!
       unless name.is_a?(String) && !name.empty? && session_token.is_a?(String) && !session_token.empty?
         raise ArgumentError, "session name and token are required"
       end
 
-      Session.new(parent: self, payload: { "name" => name, "token" => session_token })
+      Session.new(parent: self, payload: { "name" => name, "token" => session_token }, artifact_access_known: false)
     end
 
     # computer.skills.* — the Computer's learned-skill lifecycle (Computer Skills): list/get the
@@ -443,6 +456,23 @@ module PineSandbox
       @skills ||= Skills.new(self)
     end
 
+    # A public link to one of the Computer's artifacts (see Client#artifacts),
+    # served by this running Computer: anyone with the URL can download the
+    # file as it is when they open it. The link stops working after
+    # `expires_in_seconds` (60 to 2,592,000) if given, when the file is
+    # deleted, and always when the Computer stops. Returns the response Hash,
+    # { "url" => …, "expires_at" => … }; "expires_at" only with an expiry.
+    def artifact_link(path, expires_in_seconds: nil)
+      path = ArtifactPath.check!(path)
+      unless expires_in_seconds.nil? || (expires_in_seconds.is_a?(Integer) && expires_in_seconds.between?(60, 2_592_000))
+        raise ArgumentError, "expires_in_seconds must be an integer from 60 to 2592000"
+      end
+
+      rebind_on_unauthorized do
+        coordinator!.create_artifact_link(token: computer_token, path: path, expires_in_seconds: expires_in_seconds)
+      end
+    end
+
     # capabilities — the product features this Computer can use for its binding, and the limits
     # it enforces on your calls.
     def capabilities

data/lib/pinesandbox/error_taxonomy.rb

@@ -38,6 +38,8 @@ module PineSandbox
       "/errors/no-desktop-stream" => false,
       "/errors/desktop-unavailable" => false,
       "/errors/skills-unavailable" => false,
+      "/errors/artifacts-unavailable" => true,
+      "/errors/artifacts-not-configured" => false,
       "/errors/secret-in-skill" => false,
       "/errors/skill-author-failed" => true,
       "/errors/author-in-flight" => true,

data/lib/pinesandbox/errors.rb

@@ -191,6 +191,18 @@ module PineSandbox
   class HandoffExpired < GoneError; end
   class HandoffPersistenceFailed < ServerError; end
 
+  # A Computer's artifacts have no file at #path (the path you passed,
+  # relative to the Computer's artifacts). A NotFoundError, so tier rescues
+  # keep catching it.
+  class ArtifactNotFoundError < NotFoundError
+    attr_reader :path
+
+    def initialize(path:, **fields)
+      @path = path
+      super(**fields)
+    end
+  end
+
   # Problem `type` → its typed error; anything else falls back to the status tier.
   PROBLEM_TYPE_CLASSES = {
     "/errors/control-not-held" => ControlNotHeld,
@@ -240,6 +252,21 @@ module PineSandbox
     end
   end
 
+  # The Computer's artifacts take up more than its storage limit, so an
+  # upload or a copy into them is refused before anything is sent. Delete
+  # files to make room. #used_bytes and #limit_bytes are as Pine counted
+  # them when it issued the storage token.
+  class ArtifactStorageFullError < Error
+    attr_reader :used_bytes, :limit_bytes
+
+    def initialize(used_bytes:, limit_bytes:)
+      @used_bytes = used_bytes
+      @limit_bytes = limit_bytes
+      super("the Computer's artifacts use #{used_bytes} bytes, more than their limit of #{limit_bytes}; " \
+            "delete files before writing more")
+    end
+  end
+
   class StreamError < Error; end
   class StreamingUnsupportedError < Error; end
 

data/lib/pinesandbox/models/artifact_file.rb

@@ -0,0 +1,40 @@
+require "time"
+
+module PineSandbox
+  module Models
+    # One file in a Computer's artifacts. Returned by
+    # {PineSandbox::Artifacts#list}, #upload and #copy. `path` is relative to
+    # the Computer's artifacts ("research/q3.csv"); `note` is the note the file
+    # was uploaded with, if any.
+    ArtifactFile = Struct.new(
+      :path,
+      :size,
+      :updated_at,
+      :content_type,
+      :note,
+      keyword_init: true
+    ) do
+      # From a storage object, whose name is `prefix` followed by the path.
+      def self.from_object(object, prefix:)
+        new(
+          path: object["name"].to_s.delete_prefix(prefix),
+          # Storage sends the size as a decimal string.
+          size: object["size"].nil? ? nil : Integer(object["size"].to_s, 10),
+          updated_at: object["updated"] && Time.parse(object["updated"]),
+          content_type: object["contentType"],
+          note: object.dig("metadata", "pine-note")
+        )
+      end
+    end
+
+    # One page of {PineSandbox::Artifacts#list}: the files, the folders
+    # directly below the listed prefix (each ending in "/"; none when listing
+    # recursively), and the token for the next page (nil on the last one).
+    ArtifactPage = Struct.new(
+      :files,
+      :folders,
+      :next_page_token,
+      keyword_init: true
+    )
+  end
+end

data/lib/pinesandbox/models/computer_session.rb

@@ -12,12 +12,15 @@ module PineSandbox
       :token,
       :session_dir,
       :browser,
-      :blind,
+      :artifact_access,
       :created_at,
       :last_active_at,
       keyword_init: true
     ) do
-      def self.from_payload(payload)
+      # `artifact_access_known` is false for a session whose artifact access
+      # only the Computer knows (Computer#adopt_session): #artifact_access is
+      # then nil.
+      def self.from_payload(payload, artifact_access_known: true)
         return nil unless payload
         browser_payload = payload["browser"]
         new(
@@ -26,7 +29,8 @@ module PineSandbox
           token: payload["token"],
           session_dir: payload["session_dir"],
           browser: browser_payload && Browser.from_payload(browser_payload),
-          blind: payload.fetch("blind", false),
+          # An older Computer doesn't report it; its sessions have no access.
+          artifact_access: artifact_access_known ? payload.fetch("artifact_access", "none") : nil,
           created_at: payload["created_at"] && Time.parse(payload["created_at"]),
           last_active_at: payload["last_active_at"] && Time.parse(payload["last_active_at"])
         )

data/lib/pinesandbox/operations.rb

@@ -35,7 +35,9 @@ module PineSandbox
       ["cancelAuthorRun", "POST", "/v2/sessions/{name}/skills/author/{author_id}/cancel", :computer, false, false],
       ["captureCheckpoint", "POST", "/v1/coord/capture", :computer, false, false],
       ["computerUse", "POST", "/v1/sessions/{name}/computer-use", :computer, false, false],
+      ["createArtifactLink", "POST", "/v1/artifacts/links", :computer, false, false],
       ["createComputer", "POST", "/computer-sandboxes", :control, true, false],
+      ["createComputerArtifactToken", "POST", "/v1/computers/{computer_id}/artifacts/token", :control, false, false],
       ["createDiagnostic", "POST", "/v1/diagnostics", :control, true, true],
       ["createSession", "POST", "/sessions", :computer, false, false],
       ["deactivateSkill", "POST", "/v1/skills/{name}/deactivate", :computer, false, false],

data/lib/pinesandbox/sandbox_handle.rb

@@ -103,7 +103,8 @@ module PineSandbox
     def release_failed_sandbox(info, wait_timeout: 90, interval: DEFAULT_POLL_INTERVAL)
       deadline = @clock.call + wait_timeout
       unless info.status == :stopping
-        unless %i[save_failed unavailable failed terminated].include?(info.status) && info.reason != "CaptureTimeout"
+        # Accepts CAPTURE_TIMEOUT as well as CaptureTimeout to unify on SNAKE_CASE while staying backward compatible.
+        unless %i[save_failed unavailable failed terminated].include?(info.status) && !%w[CAPTURE_TIMEOUT CaptureTimeout].include?(info.reason)
           raise PineSandbox::ConflictError.new(status: 409, error_message: "The Computer has no recorded failure; use Stop or Resume")
         end
         raise PineSandbox::Error, "Server did not supply a conditional release version" if info.etag.to_s.empty?

data/lib/pinesandbox/session.rb

@@ -19,11 +19,17 @@ module PineSandbox
   # tabs, focus, epoch, drive actions, passkey intent and decisions) need the
   # session token.
   class Session
+    # What a session's agent may do with the Computer's artifacts
+    # (Computer#create_session `artifact_access:`).
+    ARTIFACT_ACCESS = %w[none read_only read_write].freeze
+
     attr_reader :info, :parent
 
-    def initialize(parent:, payload:)
+    # `artifact_access_known` is false when only the Computer knows the
+    # session's artifact access (Computer#adopt_session).
+    def initialize(parent:, payload:, artifact_access_known: true)
       @parent = parent
-      @info = Models::Session.from_payload(payload)
+      @info = Models::Session.from_payload(payload, artifact_access_known: artifact_access_known)
       raise PineSandbox::ApiError.new(status: 0, error_message: "empty session payload") if @info.nil?
     end
 
@@ -52,6 +58,15 @@ module PineSandbox
       info.session_dir
     end
 
+    # What this session's agent may do with the Computer's artifacts, as set
+    # at create: "none", "read_only" or "read_write". "none" when the Computer
+    # doesn't say (an older one). nil for a session from
+    # Computer#adopt_session, whose access isn't known: read it with
+    # Computer#session(name).
+    def artifact_access
+      info.artifact_access
+    end
+
     # session.agent.* — hand-off-the-loop driving (run/steer/answer/cancel/reset/
     # status/result/events). The agent drives; you delegate goals. See {AgentMode}.
     def agent
@@ -499,7 +514,7 @@ module PineSandbox
     # reach the browser. Driving needs control of the session, not this
     # token, so the same token serves a viewer and a driver. Re-mint before
     # each (re)connect. Returns { token:, expires_at: }. 409
-    # (NoDesktopStream) when the session is blind; 503
+    # (NoDesktopStream) for a session an older SDK created as blind; 503
     # (DesktopUnavailable) when streaming is off.
     def desktop_token
       ct_call { coordinator.mint_desktop_token(token: parent.computer_token, name: name) }

data/lib/pinesandbox/streamed_read.rb

@@ -0,0 +1,80 @@
+require "tempfile"
+
+module PineSandbox
+  # @api private — what the SDK's streamed reads of a body share: a file read
+  # from a Computer (Adapters::CoordinatorAdapter) and an artifact read from
+  # storage (Artifacts). Only a 2xx body reaches the caller, chunk by chunk as
+  # it arrives; an error answer's body is kept, bounded, for its error.
+  module StreamedRead
+    # A failed answer keeps this much of its body for the error.
+    ERROR_BODY_CAP = 64 * 1024
+    # Chunk size for passing on a body that was spooled to a temp file.
+    SPOOL_READ_SIZE = 64 * 1024
+
+    # Raised through Faraday's read loop in place of an exception from the
+    # caller's block, so the block's own error is never mistaken for a
+    # dropped connection. The streaming method raises #error again as it was.
+    class BlockError < StandardError
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+        super(error.message)
+      end
+    end
+
+    module_function
+
+    # Calls the caller's block with `args` from inside Faraday's read loop,
+    # which would turn an IOError or EPIPE from the block into a dropped
+    # connection; the block's own error comes out as a BlockError.
+    def pass(block, *args)
+      block.call(*args)
+    rescue StandardError => e
+      raise BlockError.new(e)
+    end
+
+    # Adds as much of `chunk` to `buffer` as keeps it within ERROR_BODY_CAP.
+    def keep_error_body(buffer, chunk)
+      remaining = ERROR_BODY_CAP - buffer.bytesize
+      buffer << chunk.byteslice(0, remaining) if remaining.positive?
+    end
+
+    # Reads one streamed GET. Yields the proc to set as the request's
+    # on_data; the block sends the request and returns its response. Each
+    # chunk of a 2xx body goes to `deliver` with its answer (the Faraday env,
+    # or the response) as it arrives. faraday-net_http before 3.0 passes no
+    # env and learns the status only after the body, so its chunks go to a
+    # temp file, not memory, and on to `deliver` once the status is known. An
+    # error answer's body, kept up to ERROR_BODY_CAP, becomes the response's
+    # body. Returns the response.
+    def read(deliver)
+      error_body = +""
+      spool = nil
+      on_data = proc do |chunk, _received, env|
+        if env.nil?
+          (spool ||= Tempfile.new("pinesandbox-read", binmode: true)).write(chunk)
+        elsif env.status.to_i.between?(200, 299)
+          deliver.call(chunk.b, env) unless chunk.empty?
+        else
+          keep_error_body(error_body, chunk)
+        end
+      end
+      response = yield on_data
+      if spool
+        spool.rewind
+        if response.success?
+          while (chunk = spool.read(SPOOL_READ_SIZE))
+            deliver.call(chunk, response)
+          end
+        else
+          keep_error_body(error_body, spool.read(ERROR_BODY_CAP).to_s)
+        end
+      end
+      response.env.body = error_body if !response.success? && response.body.to_s.empty?
+      response
+    ensure
+      spool&.close!
+    end
+  end
+end

data/lib/pinesandbox/version.rb

@@ -1,3 +1,5 @@
 module PineSandbox
-  VERSION = "0.3.19"
+  VERSION = "0.3.20"
+  # What the SDK's requests send as User-Agent.
+  USER_AGENT = "pinesandbox-ruby/#{VERSION}".freeze
 end

data/lib/pinesandbox.rb

@@ -8,6 +8,7 @@ require_relative "pinesandbox/models/computer_session"
 require_relative "pinesandbox/models/computer_tab"
 require_relative "pinesandbox/models/file_entry"
 require_relative "pinesandbox/models/artifact"
+require_relative "pinesandbox/models/artifact_file"
 require_relative "pinesandbox/sse_frame_parser"
 require_relative "pinesandbox/control_events"
 require_relative "pinesandbox/agent_events"
@@ -20,6 +21,7 @@ require_relative "pinesandbox/capture_keypair"
 require_relative "pinesandbox/adapters/coordinator_adapter"
 require_relative "pinesandbox/adapters/snapshot_adapter"
 require_relative "pinesandbox/skills"
+require_relative "pinesandbox/artifacts"
 require_relative "pinesandbox/author_terminal_translator"
 require_relative "pinesandbox/session"
 require_relative "pinesandbox/control_token_source"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pinesandbox
 version: !ruby/object:Gem::Version
-  version: 0.3.19
+  version: 0.3.20
 platform: ruby
 authors:
 - Pine AI
@@ -126,6 +126,7 @@ files:
 - lib/pinesandbox/agent_events.rb
 - lib/pinesandbox/agent_mode.rb
 - lib/pinesandbox/agent_turn.rb
+- lib/pinesandbox/artifacts.rb
 - lib/pinesandbox/attach_credentials_source.rb
 - lib/pinesandbox/author_terminal_translator.rb
 - lib/pinesandbox/bind_hpke.rb
@@ -147,6 +148,7 @@ files:
 - lib/pinesandbox/errors.rb
 - lib/pinesandbox/exec_stream_parser.rb
 - lib/pinesandbox/models/artifact.rb
+- lib/pinesandbox/models/artifact_file.rb
 - lib/pinesandbox/models/computer_session.rb
 - lib/pinesandbox/models/computer_tab.rb
 - lib/pinesandbox/models/file_entry.rb
@@ -159,6 +161,7 @@ files:
 - lib/pinesandbox/spec_version_middleware.rb
 - lib/pinesandbox/sse_frame_parser.rb
 - lib/pinesandbox/state_hpke.rb
+- lib/pinesandbox/streamed_read.rb
 - lib/pinesandbox/version.rb
 - lib/pinesandbox/zone.rb
 - pinesandbox.gemspec