consolle 0.2.7 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b0fccfa081563dfbdbb310a8822ccca827150906aac1208e3b72fa754eb8ab6
-  data.tar.gz: 05ab3780cce3a62638540641146dae880f7cdbe75d5ede45ce71ba32433af2ec
+  metadata.gz: 826cb825a86940fa018abc635b0c7b5914999d85da2c079801d7b98a85166adb
+  data.tar.gz: 919448817dd2064b93214be249eeb840bb328ef3c907ab9f8456daf2a8d45992
 SHA512:
-  metadata.gz: 45c5bff6c8b43e6029fb1e4d0f12cc83ce2f5925f0882c8b628394868b52f119c92e4fcc6dccaae7190e72ebdf30cc71cc1b7aeb021f6c9fbaff127fd67b9524
-  data.tar.gz: e96701a1acea38c2c90c51e4c5df56ff9e038e48551b5d34c3d17d74b4c6ad0044a8123553e1ebf2000415654da192a5f60890924b08ab904d9ad13ee8728512
+  metadata.gz: a3fb3a9902a388e4fe3d551e867c4d6ceec83aff1087e54a48f972c5bb1e029b9216ca4baa5a7c83d1eeee9905285607093cb09e790eda60583f7a66efa501d3
+  data.tar.gz: 4a5de0ff45adc32c57a35595b6743133a7f4d5cf1911d0c6dba50c5cd1ae11b0779942845af3a69d8d01c6ddb77745a81d106dfa2639b3e41ee34c91c593fcf2

data/.version

@@ -1 +1 @@
-0.2.7
+0.2.9

data/Gemfile.lock

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

data/lib/consolle/adapters/rails_console.rb

@@ -12,7 +12,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 +20,7 @@ module Consolle
         @rails_env = rails_env || 'development'
         @verbose = verbose
         @command = command || 'bin/rails console'
+        @wait_timeout = wait_timeout || 15
         @server_pid = nil
       end
 
@@ -30,7 +31,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 +147,8 @@ module Consolle
           @verbose ? 'debug' : 'info',
           @pid_path,
           @log_path,
-          @command
+          @command,
+          @wait_timeout.to_s
         ]
       end
 
@@ -156,7 +158,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 +189,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 +203,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 +228,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 +270,93 @@ module Consolle
         File.unlink(pid_file) if File.exist?(pid_file)
       end
 
-      def wait_for_server(timeout: 10)
+      def wait_for_server(timeout: 15)
         deadline = Time.now + timeout
+        server_pid = nil
+        error_found = false
+        error_message = nil
+        last_log_check = Time.now
+        ssh_auth_detected = false
+
+        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)
+                log_content = File.read(@log_path)
+                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
+              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)
+              log_content = File.read(@log_path)
+              
+              # 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
+
+          # 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

@@ -126,9 +126,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: 15
     def start
       ensure_rails_project!
       ensure_project_directories
@@ -155,7 +159,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 +557,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 +648,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 +658,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/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,7 @@ require 'pty'
 require 'timeout'
 require 'fcntl'
 require 'logger'
+require_relative '../errors'
 
 # Ruby 3.4.0+ extracts base64 as a default gem
 # Suppress warning by silencing verbose mode temporarily
@@ -26,11 +27,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 || 15
         @pid = nil
         @reader = nil
         @writer = nil
@@ -72,11 +74,31 @@ module Consolle
 
           # Encode code using Base64 to handle special characters and remote consoles
           # Ensure UTF-8 encoding to handle strings that may be tagged as ASCII-8BIT
-          utf8_code = code.encoding == Encoding::UTF_8 ? code : code.dup.force_encoding('UTF-8')
+          utf8_code = if code.encoding == Encoding::UTF_8
+                        code
+                      else
+                        # Try to handle ASCII-8BIT strings that might contain UTF-8 data
+                        temp = code.dup
+                        if code.encoding == Encoding::ASCII_8BIT
+                          # First try to interpret as UTF-8
+                          temp.force_encoding('UTF-8')
+                          if temp.valid_encoding?
+                            temp
+                          else
+                            # If not valid UTF-8, try other common encodings
+                            # or use replacement characters
+                            code.encode('UTF-8', invalid: :replace, undef: :replace)
+                          end
+                        else
+                          # For other encodings, convert to UTF-8
+                          code.encode('UTF-8')
+                        end
+                      end
           encoded_code = Base64.strict_encode64(utf8_code)
 
-          # Use eval to execute the Base64-decoded code
-          eval_command = "eval(Base64.decode64('#{encoded_code}'), IRB.CurrentContext.workspace.binding)"
+          # Use eval to execute the Base64-decoded code with exception handling
+          # Ensure decoded string is properly handled as UTF-8
+          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
@@ -93,11 +115,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
@@ -122,25 +140,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
@@ -184,6 +206,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,
@@ -226,7 +281,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
@@ -470,6 +525,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)
@@ -489,12 +545,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,7 @@
 # frozen_string_literal: true
 
 require_relative 'consolle/version'
+require_relative 'consolle/errors'
 require_relative 'consolle/cli'
 
 # Server components
@@ -9,5 +10,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.7
+  version: 0.2.9
 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,7 @@ files:
 - lib/consolle.rb
 - lib/consolle/adapters/rails_console.rb
 - lib/consolle/cli.rb
+- lib/consolle/errors.rb
 - lib/consolle/server/console_socket_server.rb
 - lib/consolle/server/console_supervisor.rb
 - lib/consolle/server/request_broker.rb