e2b 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d76a27510ea8da9f113ba2efb9aecf7c06377d20a409153491f6a918ee506a72
+  data.tar.gz: c0b1dae2a55304bbddd9211a54dea1ba964be0dcf73557a479f936627ebd67c3
+SHA512:
+  metadata.gz: 8777bb85409fab9f15c62c7d8d39856c7901616e90cc150914b78deaf4e71ba32540545dced53513cfee7641fa234815254ff529f5ebd41f533513696af436de
+  data.tar.gz: b1bd243b3741b8cba7860ffc36f0398ed5b049cb82482d65a1fea0f5da55071d3664602b3144ff7cbb06c4c90708e991ae565c9ba032ced51dac0f4e0bd6e2fb

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Voyager Team
+
+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,181 @@
+# E2B Ruby SDK
+
+Ruby SDK for [E2B](https://e2b.dev) - secure cloud sandboxes for AI-generated code execution.
+
+Aligned with the [official E2B SDKs](https://github.com/e2b-dev/E2B) (Python/JS).
+
+## Features
+
+- Sandbox lifecycle management (create, connect, pause, resume, kill)
+- Command execution with streaming output and background processes
+- Filesystem operations via proper envd RPC (list, read, write, stat, watch)
+- PTY (pseudo-terminal) support for interactive sessions
+- Git operations (clone, push, pull, branches, status, commit, etc.)
+- Directory watching with event polling
+- Snapshot support
+- Backward-compatible Client class
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'e2b', git: 'https://github.com/ya-luotao/e2b-ruby.git'
+```
+
+Then:
+
+```bash
+bundle install
+```
+
+## Quick Start
+
+```ruby
+require 'e2b'
+
+# Create a sandbox (matches official SDK pattern)
+sandbox = E2B::Sandbox.create(template: "base", api_key: ENV['E2B_API_KEY'])
+
+# Run commands
+result = sandbox.commands.run('echo "Hello from E2B!"')
+puts result.stdout
+
+# Work with files
+sandbox.files.write('/home/user/hello.txt', 'Hello, World!')
+content = sandbox.files.read('/home/user/hello.txt')
+
+# List directory (returns EntryInfo objects)
+entries = sandbox.files.list('/home/user')
+entries.each { |e| puts "#{e.name} (#{e.type}, #{e.size} bytes)" }
+
+# Background commands
+handle = sandbox.commands.run("sleep 30", background: true)
+handle.kill
+
+# PTY (interactive terminal)
+handle = sandbox.pty.create
+handle.send_stdin("ls -la\n")
+handle.kill
+
+# Git operations
+sandbox.git.clone("https://github.com/user/repo.git", path: "/home/user/repo")
+status = sandbox.git.status("/home/user/repo")
+puts "Branch: #{status.current_branch}, Clean: #{status.clean?}"
+
+# Sandbox lifecycle
+sandbox.set_timeout(600)  # extend by 10 minutes
+sandbox.pause
+sandbox.resume(timeout: 300)
+
+# Clean up
+sandbox.kill
+```
+
+## Configuration
+
+```bash
+# Option 1: Environment variable (recommended)
+export E2B_API_KEY=your-api-key
+```
+
+```ruby
+# Option 2: Global configuration
+E2B.configure do |config|
+  config.api_key = 'your-api-key'
+  config.domain = 'e2b.app'
+end
+
+# Option 3: Per-call
+sandbox = E2B::Sandbox.create(template: "base", api_key: "your-key")
+
+# Option 4: Client class (backward compatible)
+client = E2B::Client.new(api_key: "your-key")
+sandbox = client.create(template: "base")
+```
+
+## API Reference
+
+### Sandbox (class methods)
+
+| Method | Description |
+|--------|-------------|
+| `Sandbox.create(template:, timeout:, metadata:, envs:, api_key:)` | Create a new sandbox |
+| `Sandbox.connect(sandbox_id, timeout:, api_key:)` | Connect to existing sandbox |
+| `Sandbox.list(query:, limit:, api_key:)` | List running sandboxes |
+| `Sandbox.kill(sandbox_id, api_key:)` | Kill a sandbox by ID |
+
+### Sandbox (instance)
+
+| Method | Description |
+|--------|-------------|
+| `sandbox.commands` | Command execution service |
+| `sandbox.files` | Filesystem service |
+| `sandbox.pty` | PTY (terminal) service |
+| `sandbox.git` | Git operations service |
+| `sandbox.set_timeout(seconds)` | Extend sandbox lifetime |
+| `sandbox.get_host(port)` | Get host string for a port |
+| `sandbox.get_url(port)` | Get full URL for a port |
+| `sandbox.pause` / `sandbox.resume` | Pause/resume sandbox |
+| `sandbox.create_snapshot` | Create sandbox snapshot |
+| `sandbox.kill` | Terminate sandbox |
+
+### Commands (`sandbox.commands`)
+
+| Method | Description |
+|--------|-------------|
+| `run(cmd, background:, envs:, cwd:, timeout:, on_stdout:, on_stderr:)` | Run command (returns `CommandResult` or `CommandHandle`) |
+| `list` | List running processes |
+| `kill(pid)` | Kill a process |
+| `send_stdin(pid, data)` | Send stdin to a process |
+| `connect(pid)` | Connect to running process |
+
+### Filesystem (`sandbox.files`)
+
+| Method | Description |
+|--------|-------------|
+| `read(path)` | Read file content |
+| `write(path, data)` | Write file (via REST upload) |
+| `write_files(files)` | Write multiple files |
+| `list(path, depth:)` | List directory (returns `EntryInfo[]`) |
+| `get_info(path)` | Get file/dir info (returns `EntryInfo`) |
+| `exists?(path)` | Check if path exists |
+| `make_dir(path)` | Create directory |
+| `remove(path)` | Remove file/directory |
+| `rename(old_path, new_path)` | Rename/move |
+| `watch_dir(path, recursive:)` | Watch directory (returns `WatchHandle`) |
+
+### PTY (`sandbox.pty`)
+
+| Method | Description |
+|--------|-------------|
+| `create(size:, cwd:, envs:)` | Create PTY session (returns `CommandHandle`) |
+| `connect(pid)` | Connect to existing PTY |
+| `send_stdin(pid, data)` | Send input to PTY |
+| `kill(pid)` | Kill PTY process |
+| `resize(pid, size)` | Resize terminal |
+| `close_stdin(pid)` | Close PTY stdin (send EOF) |
+| `list` | List running processes |
+
+### Git (`sandbox.git`)
+
+| Method | Description |
+|--------|-------------|
+| `clone(url, path:, branch:, depth:, username:, password:)` | Clone repository |
+| `init(path, bare:, initial_branch:)` | Initialize repository |
+| `status(path)` | Get repo status (returns `GitStatus`) |
+| `branches(path)` | List branches (returns `GitBranches`) |
+| `add(path, files:, all:)` | Stage files |
+| `commit(path, message, author_name:, author_email:)` | Create commit |
+| `push(path, remote:, branch:, username:, password:)` | Push to remote |
+| `pull(path, remote:, branch:, username:, password:)` | Pull from remote |
+| `create_branch` / `checkout_branch` / `delete_branch` | Branch management |
+| `remote_add(path, name, url)` / `remote_get(path, name)` | Remote management |
+| `reset(path, mode:, target:)` / `restore(path, paths)` | Reset/restore changes |
+| `set_config` / `get_config` | Git configuration |
+| `configure_user(name, email)` | Set user name/email |
+| `dangerously_authenticate(username, password)` | Store credentials globally |
+
+## License
+
+MIT

data/lib/e2b/api/http_client.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "json"
+
+module E2B
+  module API
+    # HTTP client wrapper for E2B API communication
+    #
+    # Handles authentication, request/response processing, and error handling.
+    class HttpClient
+      # Default request timeout in seconds
+      DEFAULT_TIMEOUT = 120
+
+      # @return [String] Base URL for API requests
+      attr_reader :base_url
+
+      # Initialize a new HTTP client
+      #
+      # @param base_url [String] Base URL for API requests
+      # @param api_key [String] API key for authentication
+      # @param logger [Logger, nil] Optional logger
+      def initialize(base_url:, api_key:, logger: nil)
+        @base_url = base_url.end_with?("/") ? base_url : "#{base_url}/"
+        @api_key = api_key
+        @logger = logger
+        @connection = build_connection
+      end
+
+      # Perform a GET request
+      #
+      # @param path [String] API endpoint path
+      # @param params [Hash] Query parameters
+      # @param timeout [Integer] Request timeout in seconds
+      # @return [Hash, Array, String] Parsed response body
+      def get(path, params: {}, timeout: DEFAULT_TIMEOUT)
+        handle_response do
+          @connection.get(normalize_path(path)) do |req|
+            req.params = params
+            req.options.timeout = timeout
+          end
+        end
+      end
+
+      # Perform a POST request
+      #
+      # @param path [String] API endpoint path
+      # @param body [Hash, nil] Request body
+      # @param timeout [Integer] Request timeout in seconds
+      # @return [Hash, Array, String] Parsed response body
+      def post(path, body: nil, timeout: DEFAULT_TIMEOUT)
+        handle_response do
+          @connection.post(normalize_path(path)) do |req|
+            req.body = body.to_json if body
+            req.options.timeout = timeout
+          end
+        end
+      end
+
+      # Perform a PUT request
+      #
+      # @param path [String] API endpoint path
+      # @param body [Hash, nil] Request body
+      # @param timeout [Integer] Request timeout in seconds
+      # @return [Hash, Array, String] Parsed response body
+      def put(path, body: nil, timeout: DEFAULT_TIMEOUT)
+        handle_response do
+          @connection.put(normalize_path(path)) do |req|
+            req.body = body.to_json if body
+            req.options.timeout = timeout
+          end
+        end
+      end
+
+      # Perform a DELETE request
+      #
+      # @param path [String] API endpoint path
+      # @param timeout [Integer] Request timeout in seconds
+      # @return [Hash, Array, String, nil] Parsed response body
+      def delete(path, timeout: DEFAULT_TIMEOUT)
+        handle_response do
+          @connection.delete(normalize_path(path)) do |req|
+            req.options.timeout = timeout
+          end
+        end
+      end
+
+      private
+
+      def normalize_path(path)
+        path.to_s.sub(%r{^/+}, "")
+      end
+
+      def build_connection
+        ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
+
+        Faraday.new(url: @base_url, ssl: { verify: ssl_verify }) do |conn|
+          conn.request :json
+          conn.response :json, content_type: /\bjson$/
+          conn.adapter Faraday.default_adapter
+
+          conn.headers["X-API-Key"] = @api_key
+          conn.headers["Content-Type"] = "application/json"
+          conn.headers["Accept"] = "application/json"
+          conn.headers["User-Agent"] = "e2b-ruby-sdk/#{E2B::VERSION}"
+        end
+      end
+
+      def handle_response
+        response = yield
+        handle_error(response) unless response.success?
+
+        body = response.body
+
+        # If body is a string but should be JSON, try to parse it
+        if body.is_a?(String) && !body.empty?
+          content_type = response.headers["content-type"] rescue "unknown"
+          if content_type&.include?("json") || body.start_with?("{", "[")
+            begin
+              return JSON.parse(body)
+            rescue JSON::ParserError
+              # Return as-is if can't parse
+            end
+          end
+        end
+
+        body
+      rescue Faraday::TimeoutError => e
+        raise E2B::TimeoutError, "Request timed out: #{e.message}"
+      rescue Faraday::ConnectionFailed => e
+        raise E2B::E2BError, "Connection failed: #{e.message}"
+      end
+
+      def handle_error(response)
+        message = extract_error_message(response)
+        status = response.status
+        headers = response.headers.to_h
+
+        case status
+        when 401, 403
+          raise E2B::AuthenticationError.new(message, status_code: status, headers: headers)
+        when 404
+          raise E2B::NotFoundError.new(message, status_code: status, headers: headers)
+        when 409
+          raise E2B::ConflictError.new(message, status_code: status, headers: headers)
+        when 429
+          raise E2B::RateLimitError.new(message, status_code: status, headers: headers)
+        else
+          raise E2B::E2BError.new(message, status_code: status, headers: headers)
+        end
+      end
+
+      def extract_error_message(response)
+        body = response.body
+        return body["message"] if body.is_a?(Hash) && body["message"]
+        return body["error"] if body.is_a?(Hash) && body["error"]
+        return body.to_s if body.is_a?(String) && !body.empty?
+
+        "HTTP #{response.status} error"
+      end
+    end
+  end
+end

data/lib/e2b/client.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module E2B
+  # Client for interacting with the E2B API
+  #
+  # This class provides a convenient wrapper around {Sandbox} class methods.
+  # For the most direct API (matching the official SDK pattern), use
+  # {Sandbox.create}, {Sandbox.connect}, etc. directly.
+  #
+  # @example Using Client
+  #   client = E2B::Client.new(api_key: "your-api-key")
+  #   sandbox = client.create(template: "base")
+  #
+  # @example Using Sandbox directly (recommended, matches official SDK)
+  #   sandbox = E2B::Sandbox.create(template: "base", api_key: "your-key")
+  class Client
+    # @return [Configuration] Client configuration
+    attr_reader :config
+
+    # Initialize a new E2B client
+    #
+    # @param config_or_options [Configuration, Hash, nil] Configuration or options hash
+    # @option config_or_options [String] :api_key API key for authentication
+    # @option config_or_options [String] :api_url API URL
+    # @option config_or_options [Integer] :timeout_ms Request timeout in milliseconds
+    def initialize(config_or_options = nil)
+      @config = resolve_config(config_or_options)
+      @config.validate!
+
+      @http_client = API::HttpClient.new(
+        base_url: @config.api_url,
+        api_key: @config.api_key,
+        logger: @config.logger
+      )
+
+      @domain = Sandbox::DEFAULT_DOMAIN
+    end
+
+    # Create a new sandbox
+    #
+    # @param template [String] Template ID or alias
+    # @param timeout [Integer, nil] Sandbox timeout in seconds (or timeout_ms in milliseconds for backward compat)
+    # @param timeout_ms [Integer, nil] Sandbox timeout in milliseconds (deprecated, use timeout in seconds)
+    # @param metadata [Hash, nil] Custom metadata
+    # @param envs [Hash{String => String}, nil] Environment variables
+    # @return [Sandbox] The created sandbox instance
+    def create(template: "base", timeout: nil, timeout_ms: nil, metadata: nil, envs: nil, **_opts)
+      # Support both seconds and milliseconds for backward compat
+      timeout_seconds = if timeout
+                          timeout
+                        elsif timeout_ms
+                          (timeout_ms / 1000).to_i
+                        else
+                          (@config.sandbox_timeout_ms / 1000).to_i
+                        end
+
+      body = {
+        templateID: template,
+        timeout: timeout_seconds
+      }
+      body[:metadata] = metadata if metadata
+      body[:envVars] = envs if envs
+
+      response = @http_client.post("/sandboxes", body: body, timeout: 120)
+
+      Sandbox.new(
+        sandbox_data: response,
+        http_client: @http_client,
+        api_key: @config.api_key,
+        domain: @domain
+      )
+    end
+
+    # Connect to an existing sandbox
+    #
+    # @param sandbox_id [String] The sandbox ID
+    # @param timeout [Integer, nil] Timeout in seconds
+    # @return [Sandbox]
+    def connect(sandbox_id, timeout: nil)
+      if timeout
+        response = @http_client.post("/sandboxes/#{sandbox_id}/connect",
+          body: { timeout: timeout })
+      else
+        response = @http_client.get("/sandboxes/#{sandbox_id}")
+      end
+
+      Sandbox.new(
+        sandbox_data: response,
+        http_client: @http_client,
+        api_key: @config.api_key,
+        domain: @domain
+      )
+    end
+
+    # Get sandbox details
+    #
+    # @param sandbox_id [String] The sandbox ID
+    # @return [Sandbox]
+    def get(sandbox_id)
+      response = @http_client.get("/sandboxes/#{sandbox_id}")
+
+      Sandbox.new(
+        sandbox_data: response,
+        http_client: @http_client,
+        api_key: @config.api_key,
+        domain: @domain
+      )
+    end
+
+    # List sandboxes
+    #
+    # @param metadata [Hash, nil] Filter by metadata
+    # @param state [String, nil] Filter by state
+    # @param limit [Integer] Maximum results
+    # @return [Array<Sandbox>]
+    def list(metadata: nil, state: nil, limit: 100)
+      params = { limit: limit }
+      params[:metadata] = metadata.to_json if metadata
+      params[:state] = state if state
+
+      response = @http_client.get("/v2/sandboxes", params: params)
+
+      sandboxes = if response.is_a?(Array)
+                    response
+                  elsif response.is_a?(Hash)
+                    response["sandboxes"] || response[:sandboxes] || []
+                  else
+                    []
+                  end
+      Array(sandboxes).map do |sandbox_data|
+        Sandbox.new(
+          sandbox_data: sandbox_data,
+          http_client: @http_client,
+          api_key: @config.api_key,
+          domain: @domain
+        )
+      end
+    end
+
+    # Kill a sandbox
+    #
+    # @param sandbox_id [String] The sandbox ID
+    # @return [Boolean]
+    def kill(sandbox_id)
+      @http_client.delete("/sandboxes/#{sandbox_id}")
+      true
+    rescue NotFoundError
+      true
+    end
+
+    # Set sandbox timeout
+    #
+    # @param sandbox_id [String] The sandbox ID
+    # @param timeout [Integer] Timeout in seconds
+    def set_timeout(sandbox_id, timeout)
+      @http_client.post("/sandboxes/#{sandbox_id}/timeout",
+        body: { timeout: timeout })
+    end
+
+    # Pause a sandbox
+    #
+    # @param sandbox_id [String] The sandbox ID
+    def pause(sandbox_id)
+      @http_client.post("/sandboxes/#{sandbox_id}/pause")
+    end
+
+    # Resume a sandbox
+    #
+    # @param sandbox_id [String] The sandbox ID
+    # @param timeout [Integer, nil] New timeout in seconds
+    # @return [Sandbox]
+    def resume(sandbox_id, timeout: nil)
+      body = {}
+      body[:timeout] = timeout if timeout
+
+      response = @http_client.post("/sandboxes/#{sandbox_id}/connect", body: body)
+
+      Sandbox.new(
+        sandbox_data: response,
+        http_client: @http_client,
+        api_key: @config.api_key,
+        domain: @domain
+      )
+    end
+
+    private
+
+    def resolve_config(config_or_options)
+      case config_or_options
+      when Configuration
+        config_or_options
+      when Hash
+        Configuration.new(**config_or_options)
+      when nil
+        E2B.configuration || Configuration.new
+      else
+        raise ArgumentError, "Expected Configuration, Hash, or nil"
+      end
+    end
+  end
+end

data/lib/e2b/configuration.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module E2B
+  # Configuration for E2B SDK
+  #
+  # Supports environment variables:
+  #   - E2B_API_KEY: API key for authentication
+  #   - E2B_ACCESS_TOKEN: Access token (alternative auth)
+  #   - E2B_DOMAIN: Custom domain (default: e2b.app)
+  #   - E2B_API_URL: Custom API URL
+  #   - E2B_DEBUG: Enable debug logging
+  #
+  # @example
+  #   E2B.configure do |config|
+  #     config.api_key = "your-api-key"
+  #     config.request_timeout = 120
+  #   end
+  class Configuration
+    # Default API base URL
+    DEFAULT_API_URL = "https://api.e2b.app"
+
+    # Default domain
+    DEFAULT_DOMAIN = "e2b.app"
+
+    # Default request timeout in seconds
+    DEFAULT_REQUEST_TIMEOUT = 60
+
+    # Default sandbox timeout in seconds
+    DEFAULT_SANDBOX_TIMEOUT = 300
+
+    # Default timeout in milliseconds (backward compat)
+    DEFAULT_TIMEOUT_MS = 300_000
+
+    # Default sandbox timeout in milliseconds (backward compat)
+    DEFAULT_SANDBOX_TIMEOUT_MS = 3_600_000
+
+    # Maximum sandbox timeout (24 hours for Pro)
+    MAX_SANDBOX_TIMEOUT_MS = 86_400_000
+
+    # @return [String, nil] API key for authentication
+    attr_accessor :api_key
+
+    # @return [String, nil] Access token (alternative auth method)
+    attr_accessor :access_token
+
+    # @return [String] E2B domain
+    attr_accessor :domain
+
+    # @return [String] API base URL
+    attr_accessor :api_url
+
+    # @return [Integer] Request timeout in seconds
+    attr_accessor :request_timeout
+
+    # @return [Integer] Request timeout in milliseconds (backward compat)
+    attr_accessor :timeout_ms
+
+    # @return [Integer] Default sandbox timeout in milliseconds (backward compat)
+    attr_accessor :sandbox_timeout_ms
+
+    # @return [Boolean] Enable debug logging
+    attr_accessor :debug
+
+    # @return [String, nil] Default template ID
+    attr_accessor :default_template
+
+    # @return [Logger, nil] Optional logger
+    attr_accessor :logger
+
+    # Initialize configuration
+    #
+    # @param api_key [String, nil] API key (defaults to E2B_API_KEY env var)
+    # @param access_token [String, nil] Access token
+    # @param domain [String] E2B domain
+    # @param api_url [String] API base URL
+    # @param request_timeout [Integer] Request timeout in seconds
+    # @param timeout_ms [Integer] Request timeout in milliseconds (backward compat)
+    # @param sandbox_timeout_ms [Integer] Default sandbox timeout in milliseconds
+    # @param debug [Boolean] Enable debug logging
+    def initialize(
+      api_key: nil,
+      access_token: nil,
+      domain: nil,
+      api_url: nil,
+      request_timeout: DEFAULT_REQUEST_TIMEOUT,
+      timeout_ms: DEFAULT_TIMEOUT_MS,
+      sandbox_timeout_ms: DEFAULT_SANDBOX_TIMEOUT_MS,
+      debug: false
+    )
+      @api_key = api_key || ENV["E2B_API_KEY"]
+      @access_token = access_token || ENV["E2B_ACCESS_TOKEN"]
+      @domain = domain || ENV["E2B_DOMAIN"] || DEFAULT_DOMAIN
+      @api_url = api_url || ENV["E2B_API_URL"] || DEFAULT_API_URL
+      @request_timeout = request_timeout
+      @timeout_ms = timeout_ms
+      @sandbox_timeout_ms = sandbox_timeout_ms
+      @debug = debug || ENV["E2B_DEBUG"]&.downcase == "true"
+      @default_template = nil
+      @logger = nil
+    end
+
+    # Validate configuration
+    #
+    # @raise [ConfigurationError] If API key is missing
+    def validate!
+      if (@api_key.nil? || @api_key.empty?) && (@access_token.nil? || @access_token.empty?)
+        raise ConfigurationError,
+          "E2B API key is required. Set E2B_API_KEY environment variable or pass api_key option."
+      end
+    end
+
+    # Check if configuration is valid
+    #
+    # @return [Boolean]
+    def valid?
+      (!@api_key.nil? && !@api_key.empty?) || (!@access_token.nil? && !@access_token.empty?)
+    end
+  end
+end