consolle 0.2.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6409b2de73d4612f586ccb5ebf8bcfbf791b1b8f54ce385ff803496dea45a03
-  data.tar.gz: 446a7bfe92350892d29b10d9cdc16c83f4e1d77e1adf680b3274f793d3cc51b9
+  metadata.gz: 1a3baea2a10a98486b313276d58a6bdf7bffcf8418b490c004f756e480f38060
+  data.tar.gz: 9385cca18d1b3caa4de57c2efb98c17da15ff7cf9520f35deaf9eb0ebd21aeab
 SHA512:
-  metadata.gz: '0892cc7e9268d58ed4152a404e1901099dc0652993f01c00937e15180c3fd45ef95f0d6a0d001af0d319f6df02904e201b4266e7df96de92955af2e0475c51fa'
-  data.tar.gz: cae1d830feb7101bb50b598b41474a9216c216485b4a036af25d64dc31e9cb8880f9725c0ca2c500807cf16e866a08328ed52e7ff366a46cdd55fcb00078ae15
+  metadata.gz: d7adccc6ed3b0d47cfb80058c6f45eb82454dbe064c57a778f6bf642ddbd6755bca99c93bd460057e25ee0e5347fa006fbf63dfb723e6e2cb6c6b9b23c3fcd68
+  data.tar.gz: 99d6ac3e933f46de68891d4d48b05e590e6bd044902f00dc322d468ff136bbe2a839f614da5bf1958e8fb3173df5d5e69f535229aff2ba4cdd1d53beb87d76bf

data/.version

@@ -1 +1 @@
-0.2.8
+0.3.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    consolle (0.2.8)
+    consolle (0.3.0)
       logger (~> 1.0)
       thor (~> 1.0)
 

data/lib/consolle/adapters/rails_console.rb

@@ -5,6 +5,7 @@ require 'json'
 require 'timeout'
 require 'securerandom'
 require 'fileutils'
+require_relative '../constants'
 
 module Consolle
   module Adapters
@@ -12,7 +13,7 @@ module Consolle
       attr_reader :socket_path, :process_pid, :pid_path, :log_path
 
       def initialize(socket_path: nil, pid_path: nil, log_path: nil, rails_root: nil, rails_env: nil, verbose: false,
-                     command: nil)
+                     command: nil, wait_timeout: nil)
         @socket_path = socket_path || default_socket_path
         @pid_path = pid_path || default_pid_path
         @log_path = log_path || default_log_path
@@ -20,6 +21,7 @@ module Consolle
         @rails_env = rails_env || 'development'
         @verbose = verbose
         @command = command || 'bin/rails console'
+        @wait_timeout = wait_timeout || Consolle::DEFAULT_WAIT_TIMEOUT
         @server_pid = nil
       end
 
@@ -30,7 +32,7 @@ module Consolle
         start_server_daemon
 
         # Wait for server to be ready
-        wait_for_server(timeout: 10)
+        wait_for_server(timeout: @wait_timeout)
 
         # Get server status
         status = get_status
@@ -146,7 +148,8 @@ module Consolle
           @verbose ? 'debug' : 'info',
           @pid_path,
           @log_path,
-          @command
+          @command,
+          @wait_timeout.to_s
         ]
       end
 
@@ -156,7 +159,8 @@ module Consolle
             require 'consolle/server/console_socket_server'
             require 'logger'
           #{'  '}
-            socket_path, rails_root, rails_env, log_level, pid_path, log_path, command = ARGV
+            socket_path, rails_root, rails_env, log_level, pid_path, log_path, command, wait_timeout_str = ARGV
+            wait_timeout = wait_timeout_str ? wait_timeout_str.to_i : nil
           #{'  '}
             # Write initial log
             log_file = log_path || socket_path.sub(/\\.socket$/, '.log')
@@ -186,7 +190,8 @@ module Consolle
               rails_root: rails_root,
               rails_env: rails_env,
               logger: logger,
-              command: command
+              command: command,
+              wait_timeout: wait_timeout
             )
           #{'  '}
             puts "[Server] Starting server with log level: \#{log_level}..."
@@ -199,6 +204,17 @@ module Consolle
           rescue => e
             puts "[Server] Error: \#{e.class}: \#{e.message}"
             puts e.backtrace.join("\\n")
+            
+            # Clean up socket file if it exists
+            if defined?(socket_path) && socket_path && File.exist?(socket_path)
+              File.unlink(socket_path) rescue nil
+            end
+            
+            # Clean up PID file if it exists
+            if defined?(pid_file) && pid_file && File.exist?(pid_file)
+              File.unlink(pid_file) rescue nil
+            end
+            
             exit 1
           end
         RUBY
@@ -213,8 +229,8 @@ module Consolle
         log_file = @log_path
         pid = Process.spawn(
           *server_command,
-          out: log_file,
-          err: log_file
+          out: [log_file, 'a'],
+          err: [log_file, 'a']
         )
 
         Process.detach(pid)
@@ -255,16 +271,106 @@ module Consolle
         File.unlink(pid_file) if File.exist?(pid_file)
       end
 
-      def wait_for_server(timeout: 10)
+      def wait_for_server(timeout: Consolle::DEFAULT_WAIT_TIMEOUT)
         deadline = Time.now + timeout
+        server_pid = nil
+        error_found = false
+        error_message = nil
+        last_log_check = Time.now
+        ssh_auth_detected = false
+        
+        # Record the initial log file position to avoid reading old errors
+        initial_log_pos = if File.exist?(@log_path)
+                           File.size(@log_path)
+                         else
+                           0
+                         end
+
+        puts "Waiting for console to start (timeout: #{timeout}s)..." if @verbose
 
         while Time.now < deadline
-          return true if File.exist?(@socket_path) && get_status
+          # Check if server process is still alive by checking pid file
+          if File.exist?(@pid_path)
+            server_pid ||= File.read(@pid_path).to_i
+            begin
+              Process.kill(0, server_pid)
+              # Process is alive
+            rescue Errno::ESRCH
+              # Process died - check log for error
+              if File.exist?(@log_path)
+                File.open(@log_path, 'r') do |f|
+                  f.seek(initial_log_pos)
+                  log_content = f.read
+                  if log_content.include?('[Server] Error:')
+                    error_lines = log_content.lines.grep(/\[Server\] Error:/)
+                    error_message = error_lines.last.strip if error_lines.any?
+                  else
+                    error_message = "Server process died unexpectedly"
+                  end
+                end
+              else
+                error_message = "Server process died unexpectedly"
+              end
+              error_found = true
+              break
+            end
+          end
+
+          # Check log file periodically for errors or SSH auth messages
+          if Time.now - last_log_check > 0.5
+            last_log_check = Time.now
+            if File.exist?(@log_path) && File.size(@log_path) > initial_log_pos
+              File.open(@log_path, 'r') do |f|
+                f.seek(initial_log_pos)
+                log_content = f.read
+                
+                # Check for explicit errors
+                if log_content.include?('[Server] Error:')
+                  error_lines = log_content.lines.grep(/\[Server\] Error:/)
+                  error_message = error_lines.last.strip if error_lines.any?
+                  error_found = true
+                  break
+                end
+                
+                # Check for SSH authentication messages
+                if !ssh_auth_detected && (log_content.include?('SSH') || 
+                                         log_content.include?('ssh') || 
+                                         log_content.include?('Authenticating') ||
+                                         log_content.include?('authentication') ||
+                                         log_content.include?('1Password') ||
+                                         @command.include?('kamal') ||
+                                         @command.include?('ssh'))
+                  ssh_auth_detected = true
+                  puts "SSH authentication detected, extending timeout..." if @verbose
+                  # Extend deadline for SSH auth
+                  deadline = Time.now + [timeout, 60].max
+                end
+              end
+            end
+          end
+
+          # Check if socket exists and server is responsive
+          if File.exist?(@socket_path)
+            begin
+              status = get_status
+              if status && status['success'] && status['running']
+                return true
+              end
+            rescue StandardError
+              # Socket exists but not ready yet, continue waiting
+            end
+          end
 
           sleep 0.1
         end
 
-        raise "Server failed to start within #{timeout} seconds"
+        if error_found
+          raise "Server failed to start: #{error_message || 'Unknown error'}"
+        else
+          timeout_msg = "Server failed to start within #{timeout} seconds"
+          timeout_msg += " (SSH authentication may be required)" if ssh_auth_detected || @command.include?('ssh') || @command.include?('kamal')
+          raise timeout_msg
+        end
       end
 
       def send_request(request, timeout: 30)

data/lib/consolle/cli.rb

@@ -7,6 +7,7 @@ require 'socket'
 require 'timeout'
 require 'securerandom'
 require 'date'
+require_relative 'constants'
 require_relative 'adapters/rails_console'
 
 module Consolle
@@ -126,9 +127,13 @@ module Consolle
       Custom console commands are supported for special environments:
         cone start --command "kamal app exec -i 'bin/rails console'"
         cone start --command "docker exec -it myapp bin/rails console"
+      
+      For SSH-based commands that require authentication (e.g., 1Password SSH agent):
+        cone start --command "kamal console" --wait-timeout 60
     LONGDESC
     method_option :rails_env, type: :string, aliases: '-e', desc: 'Rails environment', default: 'development'
     method_option :command, type: :string, aliases: '-c', desc: 'Custom console command', default: 'bin/rails console'
+    method_option :wait_timeout, type: :numeric, aliases: '-w', desc: 'Timeout for console startup (seconds)', default: Consolle::DEFAULT_WAIT_TIMEOUT
     def start
       ensure_rails_project!
       ensure_project_directories
@@ -155,7 +160,7 @@ module Consolle
         clear_session_info
       end
 
-      adapter = create_rails_adapter(options[:rails_env], options[:target], options[:command])
+      adapter = create_rails_adapter(options[:rails_env], options[:target], options[:command], options[:wait_timeout])
 
       puts 'Starting Rails console...'
 
@@ -553,9 +558,20 @@ module Consolle
         puts result['result'] unless result['result'].nil?
         puts "Execution time: #{result['execution_time']}s" if options[:verbose] && result['execution_time']
       else
-        puts "Error: #{result['error']}"
+        # Display error information
+        if result['error_code']
+          puts "Error: #{result['error_code']}"
+        else
+          puts "Error: #{result['error']}"
+        end
+        
+        # Show error class in verbose mode
+        if options[:verbose] && result['error_class']
+          puts "Error Class: #{result['error_class']}"
+        end
+        
         puts result['message']
-        puts result['backtrace']&.join("\n") if options[:verbose]
+        puts result['backtrace']&.join("\n") if options[:verbose] && result['backtrace']
         exit 1
       end
     end
@@ -633,7 +649,7 @@ module Consolle
       File.join(Dir.pwd, 'tmp', 'cone', 'sessions.json')
     end
 
-    def create_rails_adapter(rails_env = 'development', target = nil, command = nil)
+    def create_rails_adapter(rails_env = 'development', target = nil, command = nil, wait_timeout = nil)
       target ||= options[:target]
 
       Consolle::Adapters::RailsConsole.new(
@@ -643,7 +659,8 @@ module Consolle
         rails_root: Dir.pwd,
         rails_env: rails_env,
         verbose: options[:verbose],
-        command: command
+        command: command,
+        wait_timeout: wait_timeout
       )
     end
 

data/lib/consolle/constants.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Consolle
+  # Default timeout for console startup (in seconds)
+  DEFAULT_WAIT_TIMEOUT = 25
+end

data/lib/consolle/errors.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Consolle
+  module Errors
+    # Base error class for all Consolle errors
+    class Error < StandardError; end
+
+    # Timeout errors hierarchy
+    class Timeout < Error; end
+
+    # Socket communication timeout (CLI/Adapter layer)
+    class SocketTimeout < Timeout
+      def initialize(timeout_seconds)
+        super("Socket operation timed out after #{timeout_seconds} seconds")
+      end
+    end
+
+    # Request processing timeout (Broker layer)
+    class RequestTimeout < Timeout
+      def initialize
+        super("Request processing timed out")
+      end
+    end
+
+    # Code execution timeout (Supervisor layer)
+    class ExecutionTimeout < Timeout
+      def initialize(timeout_seconds)
+        super("Code execution timed out after #{timeout_seconds} seconds")
+      end
+    end
+
+    # Execution errors
+    class ExecutionError < Error; end
+
+    # Syntax error in executed code
+    class SyntaxError < ExecutionError
+      def initialize(message)
+        super("Syntax error: #{message}")
+      end
+    end
+
+    # Runtime error in executed code
+    class RuntimeError < ExecutionError
+      def initialize(message)
+        super("Runtime error: #{message}")
+      end
+    end
+
+    # Load error (missing gem, file, etc.)
+    class LoadError < ExecutionError
+      def initialize(message)
+        super("Load error: #{message}")
+      end
+    end
+
+    # Error classifier to map exceptions to error codes
+    class ErrorClassifier
+      ERROR_CODE_MAP = {
+        'Timeout::Error' => 'EXECUTION_TIMEOUT',
+        'Consolle::Errors::SocketTimeout' => 'SOCKET_TIMEOUT',
+        'Consolle::Errors::RequestTimeout' => 'REQUEST_TIMEOUT',
+        'Consolle::Errors::ExecutionTimeout' => 'EXECUTION_TIMEOUT',
+        'SyntaxError' => 'SYNTAX_ERROR',
+        '::SyntaxError' => 'SYNTAX_ERROR',
+        'LoadError' => 'LOAD_ERROR',
+        '::LoadError' => 'LOAD_ERROR',
+        'NameError' => 'NAME_ERROR',
+        'NoMethodError' => 'NO_METHOD_ERROR',
+        'ArgumentError' => 'ARGUMENT_ERROR',
+        'TypeError' => 'TYPE_ERROR',
+        'ZeroDivisionError' => 'ZERO_DIVISION_ERROR',
+        'RuntimeError' => 'RUNTIME_ERROR',
+        '::RuntimeError' => 'RUNTIME_ERROR',
+        'StandardError' => 'STANDARD_ERROR',
+        'Exception' => 'EXCEPTION'
+      }.freeze
+
+      def self.to_code(exception)
+        return 'UNKNOWN_ERROR' unless exception.is_a?(Exception)
+
+        # Try exact class match first
+        error_code = ERROR_CODE_MAP[exception.class.name]
+        return error_code if error_code
+
+        # Try with leading :: for core Ruby errors
+        error_code = ERROR_CODE_MAP["::#{exception.class.name}"]
+        return error_code if error_code
+
+        # Check inheritance chain
+        exception.class.ancestors.each do |klass|
+          error_code = ERROR_CODE_MAP[klass.name]
+          return error_code if error_code
+        end
+
+        'UNKNOWN_ERROR'
+      end
+
+      def self.classify_message(error_message)
+        case error_message
+        when /syntax error/i
+          'SYNTAX_ERROR'
+        when /cannot load such file|no such file to load/i
+          'LOAD_ERROR'
+        when /undefined local variable or method/i, /undefined method/i
+          'NAME_ERROR'
+        when /wrong number of arguments/i
+          'ARGUMENT_ERROR'
+        when /execution timed out/i
+          'EXECUTION_TIMEOUT'
+        when /request timed out/i
+          'REQUEST_TIMEOUT'
+        else
+          'EXECUTION_ERROR'
+        end
+      end
+    end
+  end
+end

data/lib/consolle/server/console_socket_server.rb

@@ -12,11 +12,12 @@ module Consolle
     class ConsoleSocketServer
       attr_reader :socket_path, :logger
 
-      def initialize(socket_path:, rails_root:, rails_env: 'development', logger: nil, command: nil)
+      def initialize(socket_path:, rails_root:, rails_env: 'development', logger: nil, command: nil, wait_timeout: nil)
         @socket_path = socket_path
         @rails_root = rails_root
         @rails_env = rails_env
         @command = command || 'bin/rails console'
+        @wait_timeout = wait_timeout
         @logger = logger || begin
           log = Logger.new(STDOUT)
           log.level = Logger::DEBUG
@@ -100,7 +101,8 @@ module Consolle
           rails_root: @rails_root,
           rails_env: @rails_env,
           logger: @logger,
-          command: @command
+          command: @command,
+          wait_timeout: @wait_timeout
         )
       end
 

data/lib/consolle/server/console_supervisor.rb

@@ -4,6 +4,8 @@ require 'pty'
 require 'timeout'
 require 'fcntl'
 require 'logger'
+require_relative '../constants'
+require_relative '../errors'
 
 # Ruby 3.4.0+ extracts base64 as a default gem
 # Suppress warning by silencing verbose mode temporarily
@@ -26,11 +28,12 @@ module Consolle
       PROMPT_PATTERN = /^[^\w]*(\u001E\u001F<CONSOLLE>\u001F\u001E|\w+[-_]?\w*\([^)]*\)>|irb\([^)]+\):\d+:?\d*[>*]|>>|>)\s*$/
       CTRL_C = "\x03"
 
-      def initialize(rails_root:, rails_env: 'development', logger: nil, command: nil)
+      def initialize(rails_root:, rails_env: 'development', logger: nil, command: nil, wait_timeout: nil)
         @rails_root = rails_root
         @rails_env = rails_env
         @command = command || 'bin/rails console'
         @logger = logger || Logger.new(STDOUT)
+        @wait_timeout = wait_timeout || Consolle::DEFAULT_WAIT_TIMEOUT
         @pid = nil
         @reader = nil
         @writer = nil
@@ -94,9 +97,9 @@ module Consolle
                       end
           encoded_code = Base64.strict_encode64(utf8_code)
 
-          # Use eval to execute the Base64-decoded code
+          # Use eval to execute the Base64-decoded code with exception handling
           # Ensure decoded string is properly handled as UTF-8
-          eval_command = "eval(Base64.decode64('#{encoded_code}').force_encoding('UTF-8'), IRB.CurrentContext.workspace.binding)"
+          eval_command = "begin; eval(Base64.decode64('#{encoded_code}').force_encoding('UTF-8'), IRB.CurrentContext.workspace.binding); rescue Exception => e; puts \"\#{e.class}: \#{e.message}\"; nil; end"
           logger.debug '[ConsoleSupervisor] Sending eval command (Base64 encoded)'
           @writer.puts eval_command
           @writer.flush
@@ -113,11 +116,7 @@ module Consolle
                 @writer.flush
                 sleep 0.5
                 clear_buffer
-                return {
-                  success: false,
-                  output: "Execution timed out after #{timeout} seconds",
-                  execution_time: timeout
-                }
+                return build_timeout_response(timeout)
               end
 
               begin
@@ -142,25 +141,29 @@ module Consolle
                 # PTY can throw EIO when no data available
                 IO.select([@reader], nil, nil, 0.1)
               rescue EOFError
-                return {
-                  success: false,
-                  output: 'Console terminated',
+                return build_error_response(
+                  EOFError.new('Console terminated'),
                   execution_time: nil
-                }
+                )
               end
             end
 
             # Parse and return result
-            result = parse_output(output, eval_command)
+            parsed_result = parse_output(output, eval_command)
 
             # Log for debugging object output issues
             logger.debug "[ConsoleSupervisor] Raw output: #{output.inspect}"
-            logger.debug "[ConsoleSupervisor] Parsed result: #{result.inspect}"
+            logger.debug "[ConsoleSupervisor] Parsed result: #{parsed_result.inspect}"
 
-            { success: true, output: result, execution_time: nil }
+            # Check if the output contains an error
+            if parsed_result.is_a?(Hash) && parsed_result[:error]
+              build_error_response(parsed_result[:exception], execution_time: nil)
+            else
+              { success: true, output: parsed_result, execution_time: nil }
+            end
           rescue StandardError => e
             logger.error "[ConsoleSupervisor] Eval error: #{e.message}"
-            { success: false, output: "Error: #{e.message}", execution_time: nil }
+            build_error_response(e, execution_time: nil)
           end
         end
       end
@@ -204,6 +207,39 @@ module Consolle
 
       private
 
+      def build_timeout_response(timeout_seconds)
+        error = Consolle::Errors::ExecutionTimeout.new(timeout_seconds)
+        {
+          success: false,
+          error_class: error.class.name,
+          error_code: Consolle::Errors::ErrorClassifier.to_code(error),
+          output: error.message,
+          execution_time: timeout_seconds
+        }
+      end
+
+      def build_error_response(exception, execution_time: nil)
+        # Handle string messages that come from eval output parsing
+        if exception.is_a?(String)
+          error_code = Consolle::Errors::ErrorClassifier.classify_message(exception)
+          return {
+            success: false,
+            error_class: 'RuntimeError',
+            error_code: error_code,
+            output: exception,
+            execution_time: execution_time
+          }
+        end
+
+        {
+          success: false,
+          error_class: exception.class.name,
+          error_code: Consolle::Errors::ErrorClassifier.to_code(exception),
+          output: "#{exception.class}: #{exception.message}",
+          execution_time: execution_time
+        }
+      end
+
       def spawn_console
         env = {
           'RAILS_ENV' => @rails_env,
@@ -246,7 +282,7 @@ module Consolle
         trim_restart_history
 
         # Wait for initial prompt
-        wait_for_prompt(timeout: 15)
+        wait_for_prompt(timeout: @wait_timeout)
 
         # Configure IRB settings for automation
         configure_irb_for_automation
@@ -352,12 +388,17 @@ module Consolle
 
       def wait_for_prompt(timeout: 15, consume_all: false)
         output = +''
-        deadline = Time.now + timeout
+        start_time = Time.now
+        deadline = start_time + timeout
         prompt_found = false
         last_data_time = Time.now
 
+        logger.info "[ConsoleSupervisor] Waiting for prompt with timeout: #{timeout}s (deadline: #{deadline}, now: #{start_time})"
+
         loop do
-          if Time.now > deadline
+          current_time = Time.now
+          if current_time > deadline
+            logger.error "[ConsoleSupervisor] Timeout reached. Current: #{current_time}, Deadline: #{deadline}, Elapsed: #{current_time - start_time}s"
             logger.error "[ConsoleSupervisor] Output so far: #{output.inspect}"
             logger.error "[ConsoleSupervisor] Stripped: #{strip_ansi(output).inspect}"
             raise Timeout::Error, "No prompt after #{timeout} seconds"
@@ -490,6 +531,7 @@ module Consolle
         lines = clean.lines
         result_lines = []
         skip_echo = true
+        error_exception = nil
 
         lines.each_with_index do |line, idx|
           # Skip the eval command echo (both file-based and Base64)
@@ -509,12 +551,43 @@ module Consolle
             next
           end
 
+          # Check for error patterns
+          if !error_exception && line.match?(/^(.*Error|.*Exception):/)
+            error_match = line.match(/^((?:\w+::)*\w*(?:Error|Exception)):\s*(.*)/)
+            if error_match
+              error_class = error_match[1]
+              error_message = error_match[2]
+              
+              # Try to create the actual exception object
+              begin
+                # Handle namespaced errors
+                if error_class.include?('::')
+                  parts = error_class.split('::')
+                  klass = Object
+                  parts.each { |part| klass = klass.const_get(part) }
+                  error_exception = klass.new(error_message)
+                else
+                  # Try core Ruby error classes
+                  error_exception = Object.const_get(error_class).new(error_message)
+                end
+              rescue NameError
+                # If we can't find the exact error class, use a generic RuntimeError
+                error_exception = RuntimeError.new("#{error_class}: #{error_message}")
+              end
+            end
+          end
+
           # Collect all other lines (including return values and side effects)
           result_lines << line
         end
 
-        # Join all lines - this includes both side effects and return values
-        result_lines.join.strip
+        # If an error was detected, return it as a hash
+        if error_exception
+          { error: true, exception: error_exception, output: result_lines.join.strip }
+        else
+          # Join all lines - this includes both side effects and return values
+          result_lines.join.strip
+        end
       end
 
       def trim_restart_history

data/lib/consolle/server/request_broker.rb

@@ -172,11 +172,18 @@ module Consolle
             'execution_time' => result[:execution_time]
           }
         else
-          {
+          response = {
             'success' => false,
-            'error' => 'ExecutionError',
+            'error' => result[:error_code] || 'ExecutionError',  # Use error_code for backward compatibility
             'message' => result[:output]
           }
+          
+          # Add new fields if present
+          response['error_class'] = result[:error_class] if result[:error_class]
+          response['error_code'] = result[:error_code] if result[:error_code]
+          response['execution_time'] = result[:execution_time] if result[:execution_time]
+          
+          response
         end
       end
 

data/lib/consolle.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative 'consolle/version'
+require_relative 'consolle/constants'
+require_relative 'consolle/errors'
 require_relative 'consolle/cli'
 
 # Server components
@@ -9,5 +11,4 @@ require_relative 'consolle/server/console_supervisor'
 require_relative 'consolle/server/request_broker'
 
 module Consolle
-  class Error < StandardError; end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: consolle
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
 platform: ruby
 authors:
 - nacyot
 bindir: bin
 cert_chain: []
-date: 2025-07-24 00:00:00.000000000 Z
+date: 2025-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -79,6 +79,8 @@ files:
 - lib/consolle.rb
 - lib/consolle/adapters/rails_console.rb
 - lib/consolle/cli.rb
+- lib/consolle/constants.rb
+- lib/consolle/errors.rb
 - lib/consolle/server/console_socket_server.rb
 - lib/consolle/server/console_supervisor.rb
 - lib/consolle/server/request_broker.rb