cogbox 0.190.1

data/lib/cogbox/common/charts.rb

@@ -0,0 +1,125 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  ChartElement = CogboxToolboxApiClient::ChartElement
+
+  module ChartType
+    LINE = 'line'
+    SCATTER = 'scatter'
+    BAR = 'bar'
+    PIE = 'pie'
+    BOX_AND_WHISKER = 'box_and_whisker'
+    COMPOSITE_CHART = 'composite_chart'
+    UNKNOWN = 'unknown'
+  end
+
+  PointData = Struct.new(:label, :points, keyword_init: true)
+  BarData = Struct.new(:label, :value, :group, keyword_init: true)
+  PieData = Struct.new(:label, :angle, :radius, keyword_init: true)
+  BoxAndWhiskerData = Struct.new(:label, :min, :first_quartile, :median, :third_quartile, :max, :outliers,
+                                 keyword_init: true)
+
+  Chart = Struct.new(:type, :title, :png, :elements, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [])
+      super
+    end
+  end
+
+  Chart2D = Struct.new(:type, :title, :png, :elements, :x_label, :y_label, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [], x_label: nil, y_label: nil)
+      super
+    end
+  end
+
+  PointChart = Struct.new(:type, :title, :png, :elements, :x_label, :y_label,
+                          :x_ticks, :y_ticks, :x_tick_labels, :y_tick_labels,
+                          :x_scale, :y_scale, keyword_init: true) do
+    def initialize(type: nil, title: nil, png: nil, elements: [], x_label: nil, y_label: nil,
+                   x_ticks: nil, y_ticks: nil, x_tick_labels: nil, y_tick_labels: nil,
+                   x_scale: nil, y_scale: nil)
+      super
+    end
+  end
+
+  class LineChart < PointChart
+  end
+
+  class ScatterChart < PointChart
+  end
+
+  class BarChart < Chart2D
+  end
+
+  class PieChart < Chart
+  end
+
+  class BoxAndWhiskerChart < Chart2D
+  end
+
+  class CompositeChart < Chart
+  end
+
+  module Charts
+    Chart = Cogbox::Chart
+    ChartElement = Cogbox::ChartElement
+    ChartType = Cogbox::ChartType
+    LineChart = Cogbox::LineChart
+    ScatterChart = Cogbox::ScatterChart
+    BarChart = Cogbox::BarChart
+    PieChart = Cogbox::PieChart
+    BoxAndWhiskerChart = Cogbox::BoxAndWhiskerChart
+    CompositeChart = Cogbox::CompositeChart
+    PointData = Cogbox::PointData
+    BarData = Cogbox::BarData
+    PieData = Cogbox::PieData
+    BoxAndWhiskerData = Cogbox::BoxAndWhiskerData
+
+    def self.parse_chart(chart)
+      type = chart.type || ChartType::UNKNOWN
+      elements = (chart.elements || []).map { |el| map_element(el, type) }
+      common = { type: chart.type, title: chart.title, png: chart.png, elements: elements }
+
+      case type
+      when ChartType::LINE
+        LineChart.new(x_label: chart.x_label, y_label: chart.y_label, x_ticks: chart.x_ticks, y_ticks: chart.y_ticks,
+                      x_tick_labels: chart.x_tick_labels, y_tick_labels: chart.y_tick_labels,
+                      x_scale: chart.x_scale, y_scale: chart.y_scale, **common)
+      when ChartType::SCATTER
+        ScatterChart.new(x_label: chart.x_label, y_label: chart.y_label, x_ticks: chart.x_ticks, y_ticks: chart.y_ticks,
+                         x_tick_labels: chart.x_tick_labels, y_tick_labels: chart.y_tick_labels,
+                         x_scale: chart.x_scale, y_scale: chart.y_scale, **common)
+      when ChartType::BAR
+        BarChart.new(x_label: chart.x_label, y_label: chart.y_label, **common)
+      when ChartType::PIE
+        PieChart.new(**common)
+      when ChartType::BOX_AND_WHISKER
+        BoxAndWhiskerChart.new(x_label: chart.x_label, y_label: chart.y_label, **common)
+      when ChartType::COMPOSITE_CHART
+        CompositeChart.new(**common)
+      else
+        Chart.new(**common)
+      end
+    end
+
+    def self.map_element(el, chart_type)
+      case chart_type
+      when ChartType::LINE, ChartType::SCATTER
+        PointData.new(label: el.label, points: el.points)
+      when ChartType::BAR
+        BarData.new(label: el.label, value: el.value, group: el.group)
+      when ChartType::PIE
+        PieData.new(label: el.label, angle: el.angle, radius: el.radius)
+      when ChartType::BOX_AND_WHISKER
+        BoxAndWhiskerData.new(label: el.label, min: el.min, first_quartile: el.first_quartile,
+                              median: el.median, third_quartile: el.third_quartile,
+                              max: el.max, outliers: el.outliers)
+      else
+        el
+      end
+    end
+  end
+end

data/lib/cogbox/common/code_interpreter.rb

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

data/lib/cogbox/common/code_language.rb

@@ -0,0 +1,15 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  module CodeLanguage
+    ALL = [
+      JAVASCRIPT = :javascript,
+      PYTHON = :python,
+      TYPESCRIPT = :typescript
+    ].freeze
+  end
+end

data/lib/cogbox/common/cogbox.rb

@@ -0,0 +1,231 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  CODE_TOOLBOX_LANGUAGE_LABEL = 'code-toolbox-language'
+
+  class CreateSandboxBaseParams
+    # @return [Symbol, nil] Programming language for the Sandbox
+    attr_accessor :language
+
+    # @return [String, nil] OS user for the Sandbox
+    attr_accessor :os_user
+
+    # @return [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    attr_accessor :env_vars
+
+    # @return [Hash<String, String>, nil] Custom labels for the Sandbox
+    attr_accessor :labels
+
+    # @return [Boolean, nil] Whether the Sandbox should be public
+    attr_accessor :public
+
+    # @return [Float, nil] Timeout in seconds for Sandbox to be created and started
+    attr_accessor :timeout
+
+    # @return [Integer, nil] Auto-stop interval in minutes
+    attr_accessor :auto_stop_interval
+
+    # @return [Integer, nil] Auto-archive interval in minutes
+    attr_accessor :auto_archive_interval
+
+    # @return [Integer, nil] Auto-delete interval in minutes
+    attr_accessor :auto_delete_interval
+
+    # @return [Array<CogboxApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    attr_accessor :volumes
+
+    # @return [Boolean, nil] Whether to block all network access for the Sandbox
+    attr_accessor :network_block_all
+
+    # @return [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    attr_accessor :network_allow_list
+
+    # @return [String, nil] Comma-separated list of allowed domains for the Sandbox
+    attr_accessor :domain_allow_list
+
+    # @return [Boolean, nil] Whether the Sandbox should be ephemeral
+    attr_accessor :ephemeral
+
+    # @return [String, nil] ID or name of an existing Sandbox to link the new Sandbox to. The new
+    #   Sandbox will be scheduled on the same runner as the linked Sandbox so a local network can be
+    #   established between them. Linked Sandboxes must be
+    #   ephemeral (auto_delete_interval=0) and cannot themselves be linked to another Sandbox.
+    attr_accessor :linked_sandbox
+
+    # Initialize CreateSandboxBaseParams
+    #
+    # @param language [Symbol, nil] Programming language for the Sandbox
+    # @param os_user [String, nil] OS user for the Sandbox
+    # @param env_vars [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    # @param labels [Hash<String, String>, nil] Custom labels for the Sandbox
+    # @param public [Boolean, nil] Whether the Sandbox should be public
+    # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
+    # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
+    # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
+    # @param volumes [Array<CogboxApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
+    # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    # @param domain_allow_list [String, nil] Comma-separated list of allowed domains for the Sandbox
+    # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    # @param linked_sandbox [String, nil] ID or name of an existing Sandbox to link the new Sandbox to
+    def initialize( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      language: nil,
+      os_user: nil,
+      env_vars: nil,
+      labels: nil,
+      public: nil,
+      timeout: nil,
+      auto_stop_interval: nil,
+      auto_archive_interval: nil,
+      auto_delete_interval: nil,
+      volumes: nil,
+      network_block_all: nil,
+      network_allow_list: nil,
+      domain_allow_list: nil,
+      ephemeral: nil,
+      linked_sandbox: nil
+    )
+      @language = language
+      @os_user = os_user
+      @env_vars = env_vars
+      @labels = labels
+      @public = public
+      @timeout = timeout
+      @auto_stop_interval = auto_stop_interval
+      @auto_archive_interval = auto_archive_interval
+      @auto_delete_interval = auto_delete_interval
+      @volumes = volumes
+      @network_block_all = network_block_all
+      @network_allow_list = network_allow_list
+      @domain_allow_list = domain_allow_list
+      @ephemeral = ephemeral
+      @linked_sandbox = linked_sandbox
+
+      # Handle ephemeral and auto_delete_interval conflict
+      handle_ephemeral_auto_delete_conflict
+    end
+
+    # Convert to hash representation
+    #
+    # @return [Hash<Symbol, Object>] Hash representation of the parameters
+    def to_h # rubocop:disable Metrics/MethodLength
+      {
+        language:,
+        os_user:,
+        env_vars:,
+        labels:,
+        public:,
+        timeout:,
+        auto_stop_interval:,
+        auto_archive_interval:,
+        auto_delete_interval:,
+        volumes:,
+        network_block_all:,
+        network_allow_list:,
+        domain_allow_list:,
+        ephemeral:,
+        linked_sandbox:
+      }.compact
+    end
+
+    private
+
+    # Handle the conflict between ephemeral and auto_delete_interval
+    #
+    # @return [void]
+    def handle_ephemeral_auto_delete_conflict
+      return unless ephemeral && auto_delete_interval && !auto_delete_interval.zero?
+
+      warn(
+        "'ephemeral' and 'auto_delete_interval' cannot be used together. " \
+        'If ephemeral is true, auto_delete_interval will be ignored and set to 0.'
+      )
+      @auto_delete_interval = 0
+    end
+  end
+
+  class CreateSandboxFromImageParams < CreateSandboxBaseParams
+    # @return [String, Image] Custom Docker image to use for the Sandbox. If an Image object is provided,
+    #   the image will be dynamically built.
+    attr_accessor :image
+
+    # @return [Cogbox::Resources, nil] Resource configuration for the Sandbox. If not provided, sandbox will
+    #   have default resources.
+    attr_accessor :resources
+
+    # Initialize CreateSandboxFromImageParams
+    #
+    # @param image [String, Image] Custom Docker image to use for the Sandbox
+    # @param resources [Cogbox::Resources, nil] Resource configuration for the Sandbox
+    # @param language [Symbol, nil] Programming language for the Sandbox
+    # @param os_user [String, nil] OS user for the Sandbox
+    # @param env_vars [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    # @param labels [Hash<String, String>, nil] Custom labels for the Sandbox
+    # @param public [Boolean, nil] Whether the Sandbox should be public
+    # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
+    # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
+    # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
+    # @param volumes [Array<CogboxApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
+    # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    # @param domain_allow_list [String, nil] Comma-separated list of allowed domains for the Sandbox
+    # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    def initialize(image:, resources: nil, **args)
+      @image = image
+      @resources = resources
+
+      super(**args)
+    end
+
+    # Convert to hash representation
+    #
+    # @return [Hash<Symbol, Object>] Hash representation of the parameters
+    def to_h
+      super.merge(
+        image:,
+        resources: resources&.to_h
+      ).compact
+    end
+  end
+
+  class CreateSandboxFromSnapshotParams < CreateSandboxBaseParams
+    # @return [String, nil] Name of the snapshot to use for the Sandbox
+    attr_accessor :snapshot
+
+    # Initialize CreateSandboxFromSnapshotParams
+    #
+    # @param snapshot [String, nil] Name of the snapshot to use for the Sandbox
+    # @param language [Symbol, nil] Programming language for the Sandbox
+    # @param os_user [String, nil] OS user for the Sandbox
+    # @param env_vars [Hash<String, String>, nil] Environment variables to set in the Sandbox
+    # @param labels [Hash<String, String>, nil] Custom labels for the Sandbox
+    # @param public [Boolean, nil] Whether the Sandbox should be public
+    # @param timeout [Float, nil] Timeout in seconds for Sandbox to be created and started
+    # @param auto_stop_interval [Integer, nil] Auto-stop interval in minutes
+    # @param auto_archive_interval [Integer, nil] Auto-archive interval in minutes
+    # @param auto_delete_interval [Integer, nil] Auto-delete interval in minutes
+    # @param volumes [Array<CogboxApiClient::SandboxVolume>, nil] List of volumes mounts to attach to the Sandbox
+    # @param network_block_all [Boolean, nil] Whether to block all network access for the Sandbox
+    # @param network_allow_list [String, nil] Comma-separated list of allowed CIDR network addresses for the Sandbox
+    # @param domain_allow_list [String, nil] Comma-separated list of allowed domains for the Sandbox
+    # @param ephemeral [Boolean, nil] Whether the Sandbox should be ephemeral
+    def initialize(snapshot: nil, **args)
+      @snapshot = snapshot
+
+      super(**args)
+    end
+
+    # Convert to hash representation
+    #
+    # @return [Hash<Symbol, Object>] Hash representation of the parameters
+    def to_h
+      super.merge(snapshot:).compact
+    end
+  end
+end

data/lib/cogbox/common/file_system.rb

@@ -0,0 +1,27 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  class FileUpload
+    # @return [String, IO] File contents as a string/bytes object or a local file path or IO object.
+    #   If a string path is provided, the file content will be read from disk.
+    #   If a string content is provided, make sure it fits into memory.
+    attr_reader :source
+
+    # @return [String] Absolute destination path in the Sandbox. Relative paths are resolved based on
+    #   the sandbox working directory.
+    attr_reader :destination
+
+    # Initializes a new FileUpload instance.
+    #
+    # @param source [String, IO] File contents as a string/bytes object or a local file path or IO object.
+    # @param destination [String] Absolute destination path in the Sandbox.
+    def initialize(source, destination)
+      @source = source
+      @destination = destination
+    end
+  end
+end

data/lib/cogbox/common/git.rb

@@ -0,0 +1,20 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  # Response from the git commit.
+  class GitCommitResponse
+    # @return [String] The SHA of the commit
+    attr_reader :sha
+
+    # Initialize a new GitCommitResponse
+    #
+    # @param sha [String] The SHA of the commit
+    def initialize(sha:)
+      @sha = sha
+    end
+  end
+end