daytona-sdk 0.125.0

data/lib/daytona/git.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+module Daytona
+  class Git
+    # @return [String] The Sandbox ID
+    attr_reader :sandbox_id
+
+    # @return [DaytonaApiClient::ToolboxApi] 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 [DaytonaApiClient::ToolboxApi] API client for Sandbox operations.
+    def initialize(sandbox_id:, toolbox_api:)
+      @sandbox_id = sandbox_id
+      @toolbox_api = toolbox_api
+    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 [Daytona::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.git_add_files(sandbox_id, DaytonaApiClient::GitAddRequest.new(path:, 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 [DaytonaApiClient::ListBranchResponse] List of branches in the repository.
+    # @raise [Daytona::Sdk::Error] if listing branches fails
+    #
+    # @example
+    #   response = sandbox.git.branches("workspace/repo")
+    #   puts "Branches: #{response.branches}"
+    def branches(path)
+      toolbox_api.git_list_branches(sandbox_id, path)
+    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.
+    # @return [void]
+    # @raise [Daytona::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) # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+      toolbox_api.git_clone_repository(
+        sandbox_id,
+        DaytonaApiClient::GitCloneRequest.new(
+          url: url,
+          branch: branch,
+          path: path,
+          username: username,
+          password: password,
+          commit_id: commit_id
+        )
+      )
+    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 [Daytona::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.git_commit_changes(
+        sandbox_id,
+        DaytonaApiClient::GitCommitRequest.new(path:, message:, author:, email:, allow_empty:)
+      )
+      GitCommitResponse.new(sha: response.hash)
+    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 [Daytona::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.git_push_changes(
+        sandbox_id,
+        DaytonaApiClient::GitRepoRequest.new(path:, username:, password:)
+      )
+    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 [Daytona::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.git_pull_changes(
+        sandbox_id,
+        DaytonaApiClient::GitRepoRequest.new(path:, username:, password:)
+      )
+    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 [DaytonaApiClient::GitStatus] Repository status information including:
+    # @raise [Daytona::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.git_get_status(sandbox_id, path)
+    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 [Daytona::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.git_checkout_branch(
+        sandbox_id,
+        DaytonaApiClient::GitCheckoutRequest.new(path:, 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 [Daytona::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.git_create_branch(
+        sandbox_id,
+        DaytonaApiClient::GitBranchRequest.new(path:, name:)
+      )
+    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 [Daytona::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.git_delete_branch(
+        sandbox_id,
+        DaytonaApiClient::GitDeleteBranchRequest.new(path:, name:)
+      )
+    rescue StandardError => e
+      raise Sdk::Error, "Failed to delete branch: #{e.message}"
+    end
+  end
+end

data/lib/daytona/lsp_server.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Daytona
+  class LspServer
+    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 [DaytonaApiClient::ToolboxApi]
+    attr_reader :toolbox_api
+
+    # @return [String]
+    attr_reader :sandbox_id
+
+    # @param language_id [Symbol]
+    # @param path_to_project [String]
+    # @param toolbox_api [DaytonaApiClient::ToolboxApi]
+    # @param sandbox_id [String]
+    def initialize(language_id:, path_to_project:, toolbox_api:, sandbox_id:)
+      @language_id = language_id
+      @path_to_project = path_to_project
+      @toolbox_api = toolbox_api
+      @sandbox_id = sandbox_id
+    end
+
+    # Gets completion suggestions at a position in a file
+    #
+    # @param path [String]
+    # @param position [Daytona::LspServer::Position]
+    # @return [DaytonaApiClient::CompletionList]
+    def completions(path:, position:)
+      toolbox_api.lsp_completions(
+        sandbox_id,
+        DaytonaApiClient::LspCompletionParams.new(
+          language_id:,
+          path_to_project:,
+          uri: uri(path),
+          position: DaytonaApiClient::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.lsp_did_close(
+        sandbox_id,
+        DaytonaApiClient::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.lsp_did_open(
+        sandbox_id,
+        DaytonaApiClient::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<DaytonaApiClient::LspSymbol]
+    def document_symbols(path) = toolbox_api.lsp_document_symbols(sandbox_id, 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<DaytonaApiClient::LspSymbol]
+    def sandbox_symbols(query) = toolbox_api.lsp_workspace_symbols(sandbox_id, language_id, path_to_project, query)
+
+    # 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.lsp_start(
+        sandbox_id,
+        DaytonaApiClient::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.lsp_stop(
+        sandbox_id,
+        DaytonaApiClient::LspServerRequest.new(language_id:, path_to_project:)
+      )
+    end
+
+    private
+
+    # Convert path to file uri.
+    #
+    # @param path [String]
+    # @return [String]
+    def uri(path) = "file://#{path}"
+  end
+end

data/lib/daytona/object_storage.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'pathname'
+require 'tempfile'
+require 'zlib'
+require 'aws-sdk-s3'
+
+module Daytona
+  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 "daytona-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 = 'daytona-volume-builds'
+    private_constant :DEFAULT_BUCKET_NAME
+
+    DEFAULT_REGION = 'us-east-1'
+    private_constant :DEFAULT_REGION
+  end
+end