cogbox 0.190.1

data/lib/cogbox/git.rb

@@ -0,0 +1,335 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  class Git
+    include Instrumentation
+
+    # @return [String] The Sandbox ID
+    attr_reader :sandbox_id
+
+    # @return [CogboxToolboxApiClient::GitApi] API client for Sandbox operations
+    attr_reader :toolbox_api
+
+    # Initializes a new Git handler instance.
+    #
+    # @param sandbox_id [String] The Sandbox ID.
+    # @param toolbox_api [CogboxToolboxApiClient::GitApi] API client for Sandbox operations.
+    # @param otel_state [Cogbox::OtelState, nil]
+    def initialize(sandbox_id:, toolbox_api:, otel_state: nil)
+      @sandbox_id = sandbox_id
+      @toolbox_api = toolbox_api
+      @otel_state = otel_state
+    end
+
+    # Stages the specified files for the next commit, similar to
+    # running 'git add' on the command line.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param files [Array<String>] List of file paths or directories to stage, relative to the repository root.
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if adding files fails
+    #
+    # @example
+    #   # Stage a single file
+    #   sandbox.git.add("workspace/repo", ["file.txt"])
+    #
+    #   # Stage multiple files
+    #   sandbox.git.add("workspace/repo", [
+    #     "src/main.rb",
+    #     "spec/main_spec.rb",
+    #     "README.md"
+    #   ])
+    def add(path, files)
+      toolbox_api.add_files(CogboxToolboxApiClient::GitAddRequest.new(path:, files:))
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to add files')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to add files: #{e.message}"
+    end
+
+    # Lists branches in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @return [CogboxApiClient::ListBranchResponse] List of branches in the repository.
+    # @raise [Cogbox::Sdk::Error] if listing branches fails
+    #
+    # @example
+    #   response = sandbox.git.branches("workspace/repo")
+    #   puts "Branches: #{response.branches}"
+    def branches(path)
+      toolbox_api.list_branches(path)
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to list branches')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to list branches: #{e.message}"
+    end
+
+    # Clones a Git repository into the specified path. It supports
+    # cloning specific branches or commits, and can authenticate with the remote
+    # repository if credentials are provided.
+    #
+    # @param url [String] Repository URL to clone from.
+    # @param path [String] Path where the repository should be cloned. Relative paths are resolved
+    #   based on the sandbox working directory.
+    # @param branch [String, nil] Specific branch to clone. If not specified,
+    #   clones the default branch.
+    # @param commit_id [String, nil] Specific commit to clone. If specified,
+    #   the repository will be left in a detached HEAD state at this commit.
+    # @param username [String, nil] Git username for authentication.
+    # @param password [String, nil] Git password or token for authentication.
+    # @param insecure_skip_tls [Boolean, nil] Skip TLS certificate verification (insecure).
+    #   Use only for trusted internal Git servers with self-signed or private-CA certs;
+    #   credentials, if supplied, are transmitted over an unverified TLS connection.
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if cloning repository fails
+    #
+    # @example
+    #   # Clone the default branch
+    #   sandbox.git.clone(
+    #     url: "https://github.com/user/repo.git",
+    #     path: "workspace/repo"
+    #   )
+    #
+    #   # Clone a specific branch with authentication
+    #   sandbox.git.clone(
+    #     url: "https://github.com/user/private-repo.git",
+    #     path: "workspace/private",
+    #     branch: "develop",
+    #     username: "user",
+    #     password: "token"
+    #   )
+    #
+    #   # Clone a specific commit
+    #   sandbox.git.clone(
+    #     url: "https://github.com/user/repo.git",
+    #     path: "workspace/repo-old",
+    #     commit_id: "abc123"
+    #   )
+    def clone(url:, path:, branch: nil, commit_id: nil, username: nil, password: nil, insecure_skip_tls: nil) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      toolbox_api.clone_repository(
+        CogboxToolboxApiClient::GitCloneRequest.new(
+          url: url,
+          branch: branch,
+          path: path,
+          username: username,
+          password: password,
+          commit_id: commit_id,
+          insecure_skip_tls: insecure_skip_tls
+        )
+      )
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to clone repository')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to clone repository: #{e.message}"
+    end
+
+    # Creates a new commit with the staged changes. Make sure to stage
+    # changes using the add() method before committing.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param message [String] Commit message describing the changes.
+    # @param author [String] Name of the commit author.
+    # @param email [String] Email address of the commit author.
+    # @param allow_empty [Boolean] Allow creating an empty commit when no changes are staged. Defaults to false.
+    # @return [GitCommitResponse] Response containing the commit SHA.
+    # @raise [Cogbox::Sdk::Error] if committing changes fails
+    #
+    # @example
+    #   # Stage and commit changes
+    #   sandbox.git.add("workspace/repo", ["README.md"])
+    #   commit_response = sandbox.git.commit(
+    #     path: "workspace/repo",
+    #     message: "Update documentation",
+    #     author: "John Doe",
+    #     email: "john@example.com",
+    #     allow_empty: true
+    #   )
+    #   puts "Commit SHA: #{commit_response.sha}"
+    def commit(path:, message:, author:, email:, allow_empty: false)
+      response = toolbox_api.commit_changes(
+        CogboxToolboxApiClient::GitCommitRequest.new(path:, message:, author:, email:, allow_empty:)
+      )
+      GitCommitResponse.new(sha: response._hash)
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to commit changes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to commit changes: #{e.message}"
+    end
+
+    # Pushes all local commits on the current branch to the remote
+    # repository. If the remote repository requires authentication, provide
+    # username and password/token.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param username [String, nil] Git username for authentication.
+    # @param password [String, nil] Git password or token for authentication.
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if pushing changes fails
+    #
+    # @example
+    #   # Push without authentication (for public repos or SSH)
+    #   sandbox.git.push("workspace/repo")
+    #
+    #   # Push with authentication
+    #   sandbox.git.push(
+    #     path: "workspace/repo",
+    #     username: "user",
+    #     password: "github_token"
+    #   )
+    def push(path:, username: nil, password: nil)
+      toolbox_api.push_changes(
+        CogboxToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
+      )
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to push changes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to push changes: #{e.message}"
+    end
+
+    # Pulls changes from the remote repository. If the remote repository requires authentication,
+    # provide username and password/token.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param username [String, nil] Git username for authentication.
+    # @param password [String, nil] Git password or token for authentication.
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if pulling changes fails
+    #
+    # @example
+    #   # Pull without authentication
+    #   sandbox.git.pull("workspace/repo")
+    #
+    #   # Pull with authentication
+    #   sandbox.git.pull(
+    #     path: "workspace/repo",
+    #     username: "user",
+    #     password: "github_token"
+    #   )
+    #
+    def pull(path:, username: nil, password: nil)
+      toolbox_api.pull_changes(
+        CogboxToolboxApiClient::GitRepoRequest.new(path:, username:, password:)
+      )
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to pull changes')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to pull changes: #{e.message}"
+    end
+
+    # Gets the current Git repository status.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @return [CogboxToolboxApiClient::GitStatus] Repository status information including:
+    # @raise [Cogbox::Sdk::Error] if getting status fails
+    #
+    # @example
+    #   status = sandbox.git.status("workspace/repo")
+    #   puts "On branch: #{status.current_branch}"
+    #   puts "Commits ahead: #{status.ahead}"
+    #   puts "Commits behind: #{status.behind}"
+    def status(path)
+      toolbox_api.get_status(path)
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to get status')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to get status: #{e.message}"
+    end
+
+    # Checkout branch in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param branch [String] Name of the branch to checkout
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if checking out branch fails
+    #
+    # @example
+    #   # Checkout a branch
+    #   sandbox.git.checkout_branch("workspace/repo", "feature-branch")
+    def checkout_branch(path, branch)
+      toolbox_api.checkout_branch(
+        CogboxToolboxApiClient::GitCheckoutRequest.new(path:, branch:)
+      )
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to checkout branch')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to checkout branch: #{e.message}"
+    end
+
+    # Create branch in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param name [String] Name of the new branch to create
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if creating branch fails
+    #
+    # @example
+    #   # Create a new branch
+    #   sandbox.git.create_branch("workspace/repo", "new-feature")
+    #
+    def create_branch(path, name)
+      toolbox_api.create_branch(
+        CogboxToolboxApiClient::GitBranchRequest.new(path:, name:)
+      )
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to create branch')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to create branch: #{e.message}"
+    end
+
+    # Delete branch in the repository.
+    #
+    # @param path [String] Path to the Git repository root. Relative paths are resolved based on
+    #   the sandbox working directory.
+    # @param name [String] Name of the branch to delete
+    # @return [void]
+    # @raise [Cogbox::Sdk::Error] if deleting branch fails
+    #
+    # @example
+    #   # Delete a branch
+    #   sandbox.git.delete_branch("workspace/repo", "old-feature")
+    def delete_branch(path, name)
+      toolbox_api.delete_branch(
+        CogboxToolboxApiClient::GitDeleteBranchRequest.new(path:, name:)
+      )
+    rescue CogboxToolboxApiClient::ApiError => e
+      raise map_api_error(e, 'Failed to delete branch')
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to delete branch: #{e.message}"
+    end
+
+    instrument :add, :branches, :clone, :commit, :push, :pull, :status,
+               :checkout_branch, :create_branch, :delete_branch,
+               component: 'Git'
+
+    private
+
+    # @return [Cogbox::OtelState, nil]
+    attr_reader :otel_state
+
+    def map_api_error(api_error, prefix)
+      msg = "#{prefix}: #{api_error.message}"
+      case api_error.code
+      when 400 then Sdk::ValidationError.new(msg)
+      when 401 then Sdk::AuthenticationError.new(msg)
+      when 403 then Sdk::ForbiddenError.new(msg)
+      when 404 then Sdk::NotFoundError.new(msg)
+      when 409 then Sdk::ConflictError.new(msg)
+      when 429 then Sdk::RateLimitError.new(msg)
+      when 500..599 then Sdk::ServerError.new(msg)
+      else Sdk::Error.new(msg)
+      end
+    end
+  end
+end

data/lib/cogbox/lsp_server.rb

@@ -0,0 +1,140 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+module Cogbox
+  class LspServer
+    include Instrumentation
+
+    module Language
+      ALL = [
+        JAVASCRIPT = :javascript,
+        PYTHON = :python,
+        TYPESCRIPT = :typescript
+
+      ].freeze
+    end
+
+    # Represents a zero-based position in a text document,
+    # specified by line number and character offset.
+    Position = Data.define(:line, :character)
+
+    # @return [Symbol]
+    attr_reader :language_id
+
+    # @return [String]
+    attr_reader :path_to_project
+
+    # @return [CogboxToolboxApiClient::LspApi]
+    attr_reader :toolbox_api
+
+    # @return [String]
+    attr_reader :sandbox_id
+
+    # @param language_id [Symbol]
+    # @param path_to_project [String]
+    # @param toolbox_api [CogboxToolboxApiClient::LspApi]
+    # @param sandbox_id [String]
+    # @param otel_state [Cogbox::OtelState, nil]
+    def initialize(language_id:, path_to_project:, toolbox_api:, sandbox_id:, otel_state: nil)
+      @language_id = language_id
+      @path_to_project = path_to_project
+      @toolbox_api = toolbox_api
+      @sandbox_id = sandbox_id
+      @otel_state = otel_state
+    end
+
+    # Gets completion suggestions at a position in a file
+    #
+    # @param path [String]
+    # @param position [Cogbox::LspServer::Position]
+    # @return [CogboxApiClient::CompletionList]
+    def completions(path:, position:)
+      toolbox_api.completions(
+        CogboxToolboxApiClient::LspCompletionParams.new(
+          language_id:,
+          path_to_project:,
+          uri: uri(path),
+          position: CogboxApiClient::Position.new(line: position.line, character: position.character)
+        )
+      )
+    end
+
+    # Notify the language server that a file has been closed.
+    # This method should be called when a file is closed in the editor to allow
+    # the language server to clean up any resources associated with that file.
+    #
+    # @param path [String]
+    # @return [void]
+    def did_close(path)
+      toolbox_api.did_close(
+        CogboxToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
+      )
+    end
+
+    # Notifies the language server that a file has been opened.
+    # This method should be called when a file is opened in the editor to enable
+    # language features like diagnostics and completions for that file. The server
+    # will begin tracking the file's contents and providing language features.
+    #
+    # @param path [String]
+    # @return [void]
+    def did_open(path)
+      toolbox_api.did_open(
+        CogboxToolboxApiClient::LspDocumentRequest.new(language_id:, path_to_project:, uri: uri(path))
+      )
+    end
+
+    # Gets symbol information (functions, classes, variables, etc.) from a document.
+    #
+    # @param path [String]
+    # @return [Array<CogboxToolboxApiClient::LspSymbol]
+    def document_symbols(path) = toolbox_api.document_symbols(language_id, path_to_project, uri(path))
+
+    # Searches for symbols matching the query string across all files
+    # in the Sandbox.
+    #
+    # @param query [String]
+    # @return [Array<CogboxToolboxApiClient::LspSymbol]
+    def sandbox_symbols(query) = toolbox_api.workspace_symbols(query, language_id, path_to_project)
+
+    # Starts the language server.
+    # This method must be called before using any other LSP functionality.
+    # It initializes the language server for the specified language and project.
+    #
+    # @return [void]
+    def start
+      toolbox_api.start(
+        CogboxToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
+      )
+    end
+
+    # Stops the language server.
+    # This method should be called when the LSP server is no longer needed to
+    # free up system resources.
+    #
+    # @return [void]
+    def stop
+      toolbox_api.stop(
+        CogboxToolboxApiClient::LspServerRequest.new(language_id:, path_to_project:)
+      )
+    end
+
+    instrument :completions, :did_close, :did_open, :document_symbols, :sandbox_symbols,
+               :start, :stop,
+               component: 'LspServer'
+
+    private
+
+    # @return [Cogbox::OtelState, nil]
+    attr_reader :otel_state
+
+    # Convert path to file uri.
+    #
+    # @param path [String]
+    # @return [String]
+    def uri(path) = "file://#{path}"
+  end
+end

data/lib/cogbox/object_storage.rb

@@ -0,0 +1,173 @@
+# Copyright Daytona Platforms Inc.
+# Copyright Cognifyi
+# SPDX-License-Identifier: Apache-2.0
+
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'pathname'
+require 'tempfile'
+require 'zlib'
+require 'aws-sdk-s3'
+
+module Cogbox
+  class ObjectStorage
+    # @return [String] The name of the S3 bucket used for object storage
+    attr_reader :bucket_name
+
+    # @return [Aws::S3::Client] The S3 client
+    attr_reader :s3_client
+
+    # Initialize ObjectStorage with S3-compatible credentials
+    #
+    # @param endpoint_url [String] The endpoint URL for the object storage service
+    # @param aws_access_key_id [String] The access key ID for the object storage service
+    # @param aws_secret_access_key [String] The secret access key for the object storage service
+    # @param aws_session_token [String] The session token for the object storage service
+    # @param bucket_name [String] The name of the bucket to use (defaults to "cogbox-volume-builds")
+    # @param region [String] AWS region (defaults to us-east-1)
+    def initialize(endpoint_url:, aws_access_key_id:, aws_secret_access_key:, aws_session_token:, # rubocop:disable Metrics/ParameterLists
+                   bucket_name: DEFAULT_BUCKET_NAME, region: DEFAULT_REGION)
+      @bucket_name = bucket_name
+      @s3_client = Aws::S3::Client.new(
+        region:,
+        endpoint: endpoint_url,
+        access_key_id: aws_access_key_id,
+        secret_access_key: aws_secret_access_key,
+        session_token: aws_session_token
+      )
+    end
+
+    # Uploads a file to the object storage service
+    #
+    # @param path [String] The path to the file to upload
+    # @param organization_id [String] The organization ID to use
+    # @param archive_base_path [String, nil] The base path to use for the archive
+    # @return [String] The hash of the uploaded file
+    # @raise [Errno::ENOENT] If the path does not exist
+    def upload(path, organization_id, archive_base_path = nil)
+      raise Errno::ENOENT, "Path does not exist: #{path}" unless File.exist?(path)
+
+      path_hash = compute_hash_for_path_md5(path, archive_base_path)
+      s3_key = "#{organization_id}/#{path_hash}/context.tar"
+
+      return path_hash if file_exists_in_s3(s3_key)
+
+      upload_as_tar(s3_key, path, archive_base_path)
+
+      path_hash
+    end
+
+    # Compute the base path for an archive. Returns normalized path without the root
+    # (drive letter or leading slash).
+    #
+    # @param path_str [String] The path to compute the base path for
+    # @return [String] The base path for the given path
+    def self.compute_archive_base_path(path_str)
+      normalized_path = File.basename(path_str)
+
+      # Remove drive letter for Windows paths (e.g., C:)
+      path_without_drive = normalized_path.gsub(/^[A-Za-z]:/, '')
+
+      # Remove leading separators (both / and \)
+      path_without_drive.gsub(%r{^[/\\]+}, '')
+    end
+
+    private
+
+    # Computes the MD5 hash for a given path
+    #
+    # @param path_str [String] The path to compute the hash for
+    # @param archive_base_path [String, nil] The base path to use for the archive
+    # @return [String] The MD5 hash for the given path
+    def compute_hash_for_path_md5(path_str, archive_base_path = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      md5_hasher = Digest::MD5.new
+      abs_path_str = File.expand_path(path_str)
+
+      archive_base_path = self.class.compute_archive_base_path(path_str) if archive_base_path.nil?
+      md5_hasher.update(archive_base_path)
+
+      if File.file?(abs_path_str)
+        File.open(abs_path_str, 'rb') do |f|
+          while (chunk = f.read(8192))
+            md5_hasher.update(chunk)
+          end
+        end
+      else
+        Dir.glob(File.join(abs_path_str, '**', '*')).each do |file_path|
+          next unless File.file?(file_path)
+
+          rel_path = Pathname.new(file_path).relative_path_from(Pathname.new(abs_path_str)).to_s
+
+          md5_hasher.update(rel_path)
+
+          File.open(file_path, 'rb') do |f|
+            while (chunk = f.read(8192))
+              md5_hasher.update(chunk)
+            end
+          end
+        end
+
+        # Handle empty directories
+        Dir
+          .glob(File.join(abs_path_str, '**', '*'))
+          .select { |path| File.directory?(path) && Dir.empty?(path) }
+          .each do |empty_dir|
+            rel_dir = Pathname.new(empty_dir).relative_path_from(Pathname.new(abs_path_str)).to_s
+            md5_hasher.update(rel_dir)
+        end
+      end
+
+      md5_hasher.hexdigest
+    end
+
+    # Checks whether a specific object exists at the given path
+    #
+    # @param file_path [String] Full object path, e.g. "org/abcd123/context.tar"
+    # @return [Boolean] True if the object exists, False otherwise
+    def file_exists_in_s3(file_path)
+      s3_client.head_object(bucket: bucket_name, key: file_path)
+      true
+    rescue Aws::S3::Errors::NotFound
+      false
+    rescue StandardError => e
+      Sdk.logger.debug("Error checking file existence: #{e.message}")
+      false
+    end
+
+    # Uploads a file to the object storage service as a tar
+    #
+    # @param s3_key [String] The key to upload the file to
+    # @param source_path [String] The path to the file to upload
+    # @param archive_base_path [String, nil] The base path to use for the archive
+    def upload_as_tar(s3_key, source_path, archive_base_path = nil) # rubocop:disable Metrics/MethodLength
+      source_path = File.expand_path(source_path)
+
+      self.class.compute_archive_base_path(source_path) if archive_base_path.nil?
+
+      temp_file = Tempfile.new(['context', '.tar'])
+
+      begin
+        system('tar', '-cf', temp_file.path, '-C', File.dirname(source_path), File.basename(source_path))
+
+        File.open(temp_file.path, 'rb') do |file|
+          s3_client.put_object(
+            bucket: bucket_name,
+            key: s3_key,
+            body: file
+          )
+        end
+      ensure
+        temp_file.close
+        temp_file.unlink
+      end
+    end
+
+    DEFAULT_BUCKET_NAME = 'cogbox-volume-builds'
+    private_constant :DEFAULT_BUCKET_NAME
+
+    DEFAULT_REGION = 'us-east-1'
+    private_constant :DEFAULT_REGION
+  end
+end