e2b 0.3.4 → 0.3.5

data/lib/e2b/services/base_service.rb

@@ -15,7 +15,7 @@ module E2B
     # Connect RPC protocol (gRPC-over-HTTP with JSON encoding).
     class BaseService
       # Default envd port
-      ENVD_PORT = 49983
+      ENVD_PORT = 49_983
       DEFAULT_USERNAME = "user"
       ENVD_DEFAULT_USER_VERSION = Gem::Version.new("0.4.0")
       ENVD_RECURSIVE_WATCH_VERSION = Gem::Version.new("0.1.4")
@@ -150,7 +150,7 @@ module E2B
         end
       end
 
-      def initialize(base_url:, api_key:, access_token: nil, sandbox_id:, logger: nil)
+      def initialize(base_url:, api_key:, sandbox_id:, access_token: nil, logger: nil)
         @base_url = base_url.end_with?("/") ? base_url : "#{base_url}/"
         @api_key = api_key
         @access_token = access_token
@@ -203,16 +203,14 @@ module E2B
 
         log_debug("RPC #{service}/#{method}")
 
-        if on_event
-          return handle_streaming_rpc(path, envelope, timeout, on_event, headers)
-        end
+        return handle_streaming_rpc(path, envelope, timeout, on_event, headers) if on_event
 
         # Unary RPCs: try Connect protocol first, fall back to plain JSON.
         # Some envd versions (e.g., 0.5.4 on self-hosted) reject
         # application/connect+json for unary calls but accept application/json.
         handle_rpc_response(service, method) do
           with_retry("RPC #{service}/#{method}") do
-            url = URI.parse("#{@base_url.chomp('/')}#{path}")
+            url = URI.parse("#{@base_url.chomp("/")}#{path}")
             http = build_http(url, timeout)
 
             request = Net::HTTP::Post.new(url.request_uri)
@@ -251,17 +249,35 @@ module E2B
       # inherit proxy configuration and SSL settings. The streaming is handled
       # via Faraday's on_data callback for chunked response processing.
       #
-      # Streaming RPCs are NOT idempotent (e.g. process.Process/Start spawns a
-      # process), so we only retry while no events have been emitted to the
-      # caller yet. Once any byte has been delivered via on_event, a retry
-      # would replay output AND start a second process server-side.
+      # Retry policy:
+      #
+      # * `process.Process/Start` is **never retried**. The POST may have
+      #   already reached envd and triggered a process spawn before the
+      #   transport error surfaced; retrying would race a second process
+      #   against the first. We've seen `git clone` fail with "destination
+      #   already exists" exactly this way — first attempt spawns a process
+      #   that mkdir's the target, transport blips, retry spawns process #2
+      #   that finds the target non-empty. Caller decides what to do.
+      #
+      # * Other streaming paths (`Connect` re-attach, etc.) retry while no
+      #   events have been emitted yet. Once any byte has been delivered
+      #   via on_event, a retry would replay output to the caller, so we
+      #   abort.
       def handle_streaming_rpc(path, envelope, timeout, on_event, headers)
         result = { events: [], stdout: "", stderr: "", exit_code: nil }
         buffer = "".b
 
         full_path = normalize_path(path)
+        non_idempotent = path.end_with?("/Start")
 
-        with_retry("Streaming RPC #{path}", abort_if: -> { result[:events].any? }) do
+        retry_opts =
+          if non_idempotent
+            { max_retries: 0 }
+          else
+            { abort_if: -> { result[:events].any? } }
+          end
+
+        with_retry("Streaming RPC #{path}", **retry_opts) do
           ssl_verify = ENV.fetch("E2B_SSL_VERIFY", "true").downcase != "false"
 
           streaming_conn = Faraday.new(url: @base_url, ssl: { verify: ssl_verify }) do |conn|
@@ -287,10 +303,11 @@ module E2B
             req.body = envelope
             req.options.on_data = proc do |chunk, _overall_size, _env|
               next if chunk.nil? || chunk.empty?
+
               buffer << chunk
 
               while buffer.bytesize >= 5
-                flags = buffer.getbyte(0)
+                buffer.getbyte(0)
                 length = buffer.byteslice(1, 4).unpack1("N")
 
                 break if length.nil? || buffer.bytesize < 5 + length
@@ -324,7 +341,8 @@ module E2B
 
                     end_event = event["End"] || event["end"]
                     if end_event
-                      result[:exit_code] = parse_exit_code(end_event["exitCode"] || end_event["exit_code"] || end_event["status"])
+                      result[:exit_code] =
+                        parse_exit_code(end_event["exitCode"] || end_event["exit_code"] || end_event["status"])
                     end
                   end
 
@@ -336,9 +354,7 @@ module E2B
                     stderr_data = EnvdBase64.decode_process_output(msg["stderr"])
                     result[:stderr] += stderr_data
                   end
-                  if msg["exitCode"] || msg["exit_code"]
-                    result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"])
-                  end
+                  result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"]) if msg["exitCode"] || msg["exit_code"]
 
                   on_event.call(
                     stdout: stdout_data,
@@ -353,9 +369,7 @@ module E2B
             end
           end
 
-          unless response.status.between?(200, 299)
-            handle_error(response)
-          end
+          handle_error(response) unless response.status.between?(200, 299)
         end
 
         result
@@ -410,13 +424,20 @@ module E2B
       end
 
       def resolve_proxy(url)
-        no_proxy = ENV["no_proxy"] || ENV["NO_PROXY"]
+        no_proxy = ENV["no_proxy"] || ENV.fetch("NO_PROXY", nil)
         if no_proxy
           no_proxy_hosts = no_proxy.split(",").map(&:strip)
           return nil if no_proxy_hosts.any? { |h| url.host.end_with?(h) || h == "*" }
         end
 
-        proxy_env = url.scheme == "https" ? (ENV["https_proxy"] || ENV["HTTPS_PROXY"]) : (ENV["http_proxy"] || ENV["HTTP_PROXY"])
+        proxy_env = if url.scheme == "https"
+                      ENV["https_proxy"] || ENV.fetch("HTTPS_PROXY",
+                                                      nil)
+                    else
+                      ENV["http_proxy"] || ENV.fetch(
+                        "HTTP_PROXY", nil
+                      )
+                    end
         return nil unless proxy_env
 
         URI.parse(proxy_env)
@@ -437,14 +458,12 @@ module E2B
 
           retry_count += 1
 
-          if retry_count <= max_retries
-            sleep_time = 2**retry_count
-            log_debug("#{operation}: retry #{retry_count}/#{max_retries} after #{e.class}: #{e.message}")
-            sleep(sleep_time)
-            retry
-          else
-            raise E2B::E2BError, "#{operation} failed after #{max_retries} retries: #{e.message}"
-          end
+          raise E2B::E2BError, "#{operation} failed after #{max_retries} retries: #{e.message}" unless retry_count <= max_retries
+
+          sleep_time = 2**retry_count
+          log_debug("#{operation}: retry #{retry_count}/#{max_retries} after #{e.class}: #{e.message}")
+          sleep(sleep_time)
+          retry
         end
       end
 
@@ -455,7 +474,11 @@ module E2B
         body = response.body
 
         if body.is_a?(String) && !body.empty?
-          content_type = response.headers["content-type"] rescue "unknown"
+          content_type = begin
+            response.headers["content-type"]
+          rescue StandardError
+            "unknown"
+          end
           if content_type&.include?("json") || body.start_with?("{", "[")
             begin
               return JSON.parse(body)
@@ -472,7 +495,7 @@ module E2B
         raise E2B::E2BError, "Connection to sandbox failed: #{e.message}"
       end
 
-      def handle_rpc_response(service, method)
+      def handle_rpc_response(_service, _method)
         response = yield
 
         handle_error(response) unless response.success?
@@ -485,36 +508,32 @@ module E2B
         messages = parse_connect_stream(body)
 
         messages.each do |msg_str|
-          begin
-            msg = JSON.parse(msg_str)
-            msg = msg["result"] if msg["result"]
+          msg = JSON.parse(msg_str)
+          msg = msg["result"] if msg["result"]
 
-            result[:events] << msg
+          result[:events] << msg
 
-            if msg["event"]
-              event = msg["event"]
+          if msg["event"]
+            event = msg["event"]
 
-              data_event = event["Data"] || event["data"]
-              if data_event
-                result[:stdout] += EnvdBase64.decode_process_output(data_event["stdout"]) if data_event["stdout"]
-                result[:stderr] += EnvdBase64.decode_process_output(data_event["stderr"]) if data_event["stderr"]
-              end
-
-              end_event = event["End"] || event["end"]
-              if end_event
-                exit_value = end_event["exitCode"] || end_event["exit_code"] || end_event["status"]
-                result[:exit_code] = parse_exit_code(exit_value)
-              end
+            data_event = event["Data"] || event["data"]
+            if data_event
+              result[:stdout] += EnvdBase64.decode_process_output(data_event["stdout"]) if data_event["stdout"]
+              result[:stderr] += EnvdBase64.decode_process_output(data_event["stderr"]) if data_event["stderr"]
             end
 
-            result[:stdout] += EnvdBase64.decode_process_output(msg["stdout"]) if msg["stdout"]
-            result[:stderr] += EnvdBase64.decode_process_output(msg["stderr"]) if msg["stderr"]
-            if msg["exitCode"] || msg["exit_code"]
-              result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"])
+            end_event = event["End"] || event["end"]
+            if end_event
+              exit_value = end_event["exitCode"] || end_event["exit_code"] || end_event["status"]
+              result[:exit_code] = parse_exit_code(exit_value)
             end
-          rescue JSON::ParserError
-            # Skip unparseable messages
           end
+
+          result[:stdout] += EnvdBase64.decode_process_output(msg["stdout"]) if msg["stdout"]
+          result[:stderr] += EnvdBase64.decode_process_output(msg["stderr"]) if msg["stderr"]
+          result[:exit_code] = parse_exit_code(msg["exitCode"] || msg["exit_code"]) if msg["exitCode"] || msg["exit_code"]
+        rescue JSON::ParserError
+          # Skip unparseable messages
         end
 
         result
@@ -569,9 +588,9 @@ module E2B
 
         str = value.to_s
         if str =~ /exit status (\d+)/i
-          $1.to_i
+          ::Regexp.last_match(1).to_i
         elsif str =~ /^(\d+)$/
-          $1.to_i
+          ::Regexp.last_match(1).to_i
         else
           1
         end

data/lib/e2b/services/command_handle.rb

@@ -189,9 +189,7 @@ module E2B
       # @raise [CommandExitError] if exit code is non-zero
       def wait(on_stdout: nil, on_stderr: nil, on_pty: nil)
         consume_events(on_stdout: on_stdout, on_stderr: on_stderr, on_pty: on_pty)
-        unless @disconnected || completed?
-          raise E2BError, "Command ended without an end event"
-        end
+        raise E2BError, "Command ended without an end event" unless @disconnected || completed?
 
         build_result.tap do |cmd_result|
           unless cmd_result.success?
@@ -269,15 +267,9 @@ module E2B
         return if @finished
 
         each do |stdout_chunk, stderr_chunk, pty_chunk|
-          if stdout_chunk
-            on_stdout&.call(stdout_chunk)
-          end
-          if stderr_chunk
-            on_stderr&.call(stderr_chunk)
-          end
-          if pty_chunk
-            on_pty&.call(pty_chunk)
-          end
+          on_stdout&.call(stdout_chunk) if stdout_chunk
+          on_stderr&.call(stderr_chunk) if stderr_chunk
+          on_pty&.call(pty_chunk) if pty_chunk
         end
 
         @finished = true
@@ -306,7 +298,7 @@ module E2B
       #
       # @yield [stdout, stderr, pty]
       # @return [void]
-      def iterate_materialized_events
+      def iterate_materialized_events(&block)
         events = result_value(:events) || []
         while @materialized_event_index < events.length
           break if @disconnected
@@ -314,9 +306,7 @@ module E2B
           event_hash = events[@materialized_event_index]
           @materialized_event_index += 1
 
-          process_message(event_hash) do |stdout_chunk, stderr_chunk, pty_chunk|
-            yield stdout_chunk, stderr_chunk, pty_chunk
-          end
+          process_message(event_hash, &block)
         end
       end
 
@@ -327,14 +317,12 @@ module E2B
       #
       # @yield [stdout, stderr, pty]
       # @return [void]
-      def iterate_streaming_events
+      def iterate_streaming_events(&block)
         catch(:stop_iteration) do
           @events_proc.call do |event_hash|
             throw :stop_iteration if @disconnected
 
-            process_message(event_hash) do |stdout_chunk, stderr_chunk, pty_chunk|
-              yield stdout_chunk, stderr_chunk, pty_chunk
-            end
+            process_message(event_hash, &block)
           end
         end
       end
@@ -353,11 +341,11 @@ module E2B
       # @param message [Hash] A raw stream message
       # @yield [stdout, stderr, pty]
       # @return [void]
-      def process_message(message)
+      def process_message(message, &block)
         return unless message.is_a?(Hash)
 
         event = message["event"]
-        process_event(event) { |stdout_chunk, stderr_chunk, pty_chunk| yield stdout_chunk, stderr_chunk, pty_chunk } if event.is_a?(Hash)
+        process_event(event, &block) if event.is_a?(Hash)
 
         if event.nil?
           stdout_chunk = EnvdBase64.decode_process_output(message["stdout"])

data/lib/e2b/services/commands.rb

@@ -25,6 +25,7 @@ module E2B
     #   handle.kill
     class Commands < BaseService
       include LiveStreamable
+
       # Run a command in the sandbox
       #
       # @param cmd [String] Command to execute (run via /bin/bash -l -c)
@@ -93,10 +94,10 @@ module E2B
         end
 
         response = envd_rpc("process.Process", "Start",
-          body: body,
-          timeout: effective_timeout,
-          headers: headers,
-          on_event: streaming_callback)
+                            body: body,
+                            timeout: effective_timeout,
+                            headers: headers,
+                            on_event: streaming_callback)
 
         # Return CommandResult for foreground processes
         result = build_result(response)
@@ -120,16 +121,15 @@ module E2B
       # @return [Array<Hash>] List of running processes with pid, config, tag
       def list(request_timeout: nil)
         response = envd_rpc("process.Process", "List",
-          body: {},
-          timeout: request_timeout || 30)
+                            body: {},
+                            timeout: request_timeout || 30)
 
         processes = []
         events = response[:events] || []
         events.each do |event|
           next unless event.is_a?(Hash)
-          if event["processes"]
-            processes.concat(Array(event["processes"]))
-          end
+
+          processes.concat(Array(event["processes"])) if event["processes"]
         end
         processes
       end
@@ -141,12 +141,12 @@ module E2B
       # @return [Boolean] true if killed, false if not found
       def kill(pid, request_timeout: nil, headers: nil)
         envd_rpc("process.Process", "SendSignal",
-          body: {
-            process: { pid: pid },
-            signal: 9 # SIGKILL
-          },
-          headers: headers,
-          timeout: request_timeout || 30)
+                 body: {
+                   process: { pid: pid },
+                   signal: 9 # SIGKILL
+                 },
+                 headers: headers,
+                 timeout: request_timeout || 30)
         true
       rescue E2B::NotFoundError
         false
@@ -166,12 +166,12 @@ module E2B
       def send_stdin(pid, data, request_timeout: nil, headers: nil)
         encoded = Base64.strict_encode64(data.to_s)
         envd_rpc("process.Process", "SendInput",
-          body: {
-            process: { pid: pid },
-            input: { stdin: encoded }
-          },
-          headers: headers,
-          timeout: request_timeout || 30)
+                 body: {
+                   process: { pid: pid },
+                   input: { stdin: encoded }
+                 },
+                 headers: headers,
+                 timeout: request_timeout || 30)
       end
 
       # Close the stdin of a running process.
@@ -185,9 +185,9 @@ module E2B
       # @raise [E2B::E2BError] if the process is not found
       def close_stdin(pid, request_timeout: nil, headers: nil)
         envd_rpc("process.Process", "CloseStdin",
-          body: { process: { pid: pid } },
-          headers: headers,
-          timeout: request_timeout || 30)
+                 body: { process: { pid: pid } },
+                 headers: headers,
+                 timeout: request_timeout || 30)
       end
 
       # Connect to a running process
@@ -222,10 +222,9 @@ module E2B
         events = response[:events] || []
         events.each do |event|
           next unless event.is_a?(Hash) && event["event"]
+
           end_event = event["event"]["End"] || event["event"]["end"]
-          if end_event
-            error = end_event["error"] if end_event["error"] && !end_event["error"].empty?
-          end
+          error = end_event["error"] if end_event && end_event["error"] && !end_event["error"].empty?
         end
 
         CommandResult.new(

data/lib/e2b/services/filesystem.rb

@@ -99,9 +99,9 @@ module E2B
       #   entries.each { |e| puts "#{e.name} (#{e.type})" }
       def list(path, depth: 1, user: nil, request_timeout: 60)
         response = envd_rpc("filesystem.Filesystem", "ListDir",
-          body: { path: path, depth: depth },
-          timeout: request_timeout,
-          headers: user_auth_headers(user))
+                            body: { path: path, depth: depth },
+                            timeout: request_timeout,
+                            headers: user_auth_headers(user))
 
         entries = extract_entries(response)
         entries.map { |e| Models::EntryInfo.from_hash(e) }
@@ -132,9 +132,9 @@ module E2B
       # @return [Models::EntryInfo] File/directory info
       def get_info(path, user: nil, request_timeout: 30)
         response = envd_rpc("filesystem.Filesystem", "Stat",
-          body: { path: path },
-          timeout: request_timeout,
-          headers: user_auth_headers(user))
+                            body: { path: path },
+                            timeout: request_timeout,
+                            headers: user_auth_headers(user))
 
         entry_data = extract_entry(response)
         Models::EntryInfo.from_hash(entry_data)
@@ -147,9 +147,9 @@ module E2B
       # @param request_timeout [Integer] Request timeout in seconds
       def remove(path, user: nil, request_timeout: 30)
         envd_rpc("filesystem.Filesystem", "Remove",
-          body: { path: path },
-          timeout: request_timeout,
-          headers: user_auth_headers(user))
+                 body: { path: path },
+                 timeout: request_timeout,
+                 headers: user_auth_headers(user))
       end
 
       # Rename/move a file or directory
@@ -161,9 +161,9 @@ module E2B
       # @return [Models::EntryInfo] Info about the moved entry
       def rename(old_path, new_path, user: nil, request_timeout: 30)
         response = envd_rpc("filesystem.Filesystem", "Move",
-          body: { source: old_path, destination: new_path },
-          timeout: request_timeout,
-          headers: user_auth_headers(user))
+                            body: { source: old_path, destination: new_path },
+                            timeout: request_timeout,
+                            headers: user_auth_headers(user))
 
         entry_data = extract_entry(response)
         Models::EntryInfo.from_hash(entry_data)
@@ -177,9 +177,9 @@ module E2B
       # @return [Boolean] true if created successfully
       def make_dir(path, user: nil, request_timeout: 30)
         envd_rpc("filesystem.Filesystem", "MakeDir",
-          body: { path: path },
-          timeout: request_timeout,
-          headers: user_auth_headers(user))
+                 body: { path: path },
+                 timeout: request_timeout,
+                 headers: user_auth_headers(user))
         true
       end
 
@@ -202,13 +202,13 @@ module E2B
       def watch_dir(path, recursive: false, user: nil, request_timeout: 30)
         if recursive && !supports_recursive_watch?
           raise E2B::TemplateError,
-            "You need to update the template to use recursive watching. You can do this by running `e2b template build` in the directory with the template."
+                "You need to update the template to use recursive watching. You can do this by running `e2b template build` in the directory with the template."
         end
 
         response = envd_rpc("filesystem.Filesystem", "CreateWatcher",
-          body: { path: path, recursive: recursive },
-          timeout: request_timeout,
-          headers: user_auth_headers(user))
+                            body: { path: path, recursive: recursive },
+                            timeout: request_timeout,
+                            headers: user_auth_headers(user))
 
         watcher_id = response[:events]&.first&.dig("watcherId") ||
                      response["watcherId"] ||
@@ -257,9 +257,8 @@ module E2B
 
           response = execute_http_request(uri, request, timeout: timeout)
           unless successful_response?(response)
-            if response.code.to_i == 404
-              raise E2B::NotFoundError.new("File not found", status_code: 404)
-            end
+            raise E2B::NotFoundError.new("File not found", status_code: 404) if response.code.to_i == 404
+
             raise E2B::E2BError, "File read failed: HTTP #{response.code}"
           end
 
@@ -281,9 +280,7 @@ module E2B
           apply_request_headers(request)
 
           response = execute_http_request(uri, request, timeout: timeout)
-          unless successful_response?(response)
-            raise E2B::E2BError, "File upload failed: HTTP #{response.code}"
-          end
+          raise E2B::E2BError, "File upload failed: HTTP #{response.code}" unless successful_response?(response)
 
           parse_upload_response(response.body)
         end
@@ -344,13 +341,11 @@ module E2B
         rescue OpenSSL::SSL::SSLError, Errno::ECONNRESET, EOFError, Net::OpenTimeout, Net::ReadTimeout => e
           retry_count += 1
 
-          if retry_count <= max_retries
-            sleep_time = 2**retry_count
-            sleep(sleep_time)
-            retry
-          else
-            raise E2B::E2BError, "#{operation} failed after #{max_retries} retries: #{e.message}"
-          end
+          raise E2B::E2BError, "#{operation} failed after #{max_retries} retries: #{e.message}" unless retry_count <= max_retries
+
+          sleep_time = 2**retry_count
+          sleep(sleep_time)
+          retry
         end
       end
 
@@ -365,6 +360,7 @@ module E2B
 
         events.each do |event|
           next unless event.is_a?(Hash)
+
           # Direct entries field
           if event["entries"]
             entries.concat(Array(event["entries"]))
@@ -400,6 +396,7 @@ module E2B
         events.each do |event|
           next unless event.is_a?(Hash)
           return event["watcherId"] || event["watcher_id"] if event["watcherId"] || event["watcher_id"]
+
           result = event["result"]
           return result["watcherId"] || result["watcher_id"] if result.is_a?(Hash) && (result["watcherId"] || result["watcher_id"])
         end

data/lib/e2b/services/git.rb

@@ -84,7 +84,7 @@ module E2B
       #
       # @return [Boolean]
       def has_conflicts?
-        file_status.any? { |f| f.index_status == "u" || f.index_status == "U" }
+        file_status.any? { |f| %w[u U].include?(f.index_status) }
       end
 
       # Number of staged files
@@ -105,7 +105,7 @@ module E2B
       #
       # @return [Integer]
       def conflict_count
-        file_status.count { |f| f.index_status == "u" || f.index_status == "U" }
+        file_status.count { |f| %w[u U].include?(f.index_status) }
       end
 
       # Number of modified files (in the working tree)
@@ -571,7 +571,7 @@ module E2B
                                    envs: nil, user: nil, cwd: nil, timeout: nil)
         # Configure credential helper to use the store
         set_config("credential.helper", "store", scope: "global",
-                   envs: envs, user: user, cwd: cwd, timeout: timeout)
+                                                 envs: envs, user: user, cwd: cwd, timeout: timeout)
 
         # Write credentials to the credential store via git credential approve
         credential_input = [
@@ -583,7 +583,7 @@ module E2B
         ].join("\n")
 
         escaped_input = Shellwords.escape(credential_input)
-        args = ["credential", "approve"]
+        args = %w[credential approve]
         cmd = build_git_command(args, nil)
         full_cmd = "echo #{escaped_input} | #{cmd}"
 
@@ -604,9 +604,9 @@ module E2B
       # @return [void]
       def configure_user(name, email, scope: "global", path: nil, envs: nil, user: nil, cwd: nil, timeout: nil)
         set_config("user.name", name, scope: scope, path: path,
-                   envs: envs, user: user, cwd: cwd, timeout: timeout)
+                                      envs: envs, user: user, cwd: cwd, timeout: timeout)
         set_config("user.email", email, scope: scope, path: path,
-                   envs: envs, user: user, cwd: cwd, timeout: timeout)
+                                        envs: envs, user: user, cwd: cwd, timeout: timeout)
       end
 
       private
@@ -781,7 +781,7 @@ module E2B
       def validate_scope!(scope)
         return if VALID_SCOPES.include?(scope)
 
-        raise E2B::E2BError, "Invalid git config scope '#{scope}'. Must be one of: #{VALID_SCOPES.join(', ')}"
+        raise E2B::E2BError, "Invalid git config scope '#{scope}'. Must be one of: #{VALID_SCOPES.join(", ")}"
       end
 
       # Convert a scope name to its git CLI flag
@@ -835,7 +835,7 @@ module E2B
             file_status << GitFileStatus.new(path: filepath.split("\t").first, index_status: idx, work_tree_status: wt)
           when /\Au (.)(.) .+ .+ .+ .+ .+ (.+)\z/
             # Unmerged entry
-            idx = Regexp.last_match(1)
+            Regexp.last_match(1)
             wt = Regexp.last_match(2)
             filepath = Regexp.last_match(3)
             file_status << GitFileStatus.new(path: filepath, index_status: "u", work_tree_status: wt)