consolle 0.3.2 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cbcbc211408bd181f9bb30dc1e20ad0c4798fd3501b4b5b5e4e157c1ed63850
-  data.tar.gz: 71770bb16b893aa72b3c72edd8fff3f0f21c56596e7c1eac914b3f1981e1d8dd
+  metadata.gz: 4cf7b0621257f76801c7a5f4f064c511be503aadc56abf6a396d0fac9017506a
+  data.tar.gz: 3b393a2a0e389ebf93172ed7f1d38edb77fd1daa9eaf56f759200919683c1a04
 SHA512:
-  metadata.gz: 37f73c3bccdb446557479ea5bbccd40bf70d9b95d306d49fd6f997911183b61cffb1042625953991b52fc99a383857090dc2170d24b13720adbb112b284b3886
-  data.tar.gz: e8d66da8e20ee744762ae50bc9f7b43d4a56be28bef75ace9a7e8737cd6e3491420a615120b798d118fbe97a1fb30e0918353c26053a036fe8186770bb5b7bf3
+  metadata.gz: 992c65047ff3db88c005465133723c75d20841e13519c39e6cbae63f63abb2f61da8f11ea624763fa9d0bd220d27cd58ba8420769634a339e02a860706966bf5
+  data.tar.gz: 5459c740c89fcf7df8250348cea205cb4d8d6db52d6b50e2e3b695efa8998fa421936e363c2fc3559e6f666c4cd0f4b403dcab023c162984194cb8e31eddef6a

data/.version

@@ -1 +1 @@
-0.3.2
+0.3.4

data/Gemfile.lock

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

data/lib/consolle/adapters/rails_console.rb

@@ -78,7 +78,7 @@ module Consolle
         nil
       end
 
-      def send_code(code, timeout: 15)
+      def send_code(code, timeout: 30)
         raise 'Console is not running' unless running?
 
         request = {

data/lib/consolle/cli.rb

@@ -484,7 +484,7 @@ module Consolle
       #{'  '}
       The console must be started first with 'cone start'.
     LONGDESC
-    method_option :timeout, type: :numeric, desc: 'Timeout in seconds', default: 15
+    method_option :timeout, type: :numeric, desc: 'Timeout in seconds', default: 30
     method_option :file, type: :string, aliases: '-f', desc: 'Read Ruby code from FILE'
     method_option :raw, type: :boolean, desc: 'Do not apply escape fixes for Claude Code (keep \\! as is)'
     def exec(*code_parts)
@@ -556,7 +556,8 @@ module Consolle
       if result['success']
         # Always print result, even if empty (multiline code often returns empty string)
         puts result['result'] unless result['result'].nil?
-        puts "Execution time: #{result['execution_time']}s" if options[:verbose] && result['execution_time']
+        # Always show execution time when available
+        puts "Execution time: #{result['execution_time'].round(3)}s" if result['execution_time']
       else
         # Display error information
         if result['error_code']
@@ -572,6 +573,10 @@ module Consolle
         
         puts result['message']
         puts result['backtrace']&.join("\n") if options[:verbose] && result['backtrace']
+        
+        # Show execution time for errors too
+        puts "Execution time: #{result['execution_time'].round(3)}s" if result['execution_time']
+        
         exit 1
       end
     end
@@ -616,8 +621,11 @@ module Consolle
       File.join(Dir.pwd, 'tmp', 'cone', "#{target}.log")
     end
 
-    def send_code_to_socket(socket_path, code, timeout: 15)
+    def send_code_to_socket(socket_path, code, timeout: 30)
       request_id = SecureRandom.uuid
+      # Ensure code is UTF-8 encoded
+      code = code.force_encoding('UTF-8') if code.respond_to?(:force_encoding)
+      
       request = {
         'action' => 'eval',
         'code' => code,
@@ -625,23 +633,57 @@ module Consolle
         'request_id' => request_id
       }
 
+      STDERR.puts "[DEBUG] Creating socket connection to: #{socket_path}" if ENV['DEBUG']
+      
       Timeout.timeout(timeout + 5) do
         socket = UNIXSocket.new(socket_path)
+        STDERR.puts "[DEBUG] Socket connected" if ENV['DEBUG']
 
-        # Send request as single line JSON
-        socket.write(JSON.generate(request))
+        # Send request as single line JSON with UTF-8 encoding
+        json_data = JSON.generate(request)
+        STDERR.puts "[DEBUG] JSON data size: #{json_data.bytesize} bytes" if ENV['DEBUG']
+        
+        # Debug: Check for newlines in JSON
+        if ENV['DEBUG'] && json_data.include?("\n")
+          STDERR.puts "[DEBUG] WARNING: JSON contains literal newline!"
+          File.write("/tmp/cone_debug.json", json_data) if ENV['DEBUG_SAVE']
+        end
+        
+        STDERR.puts "[DEBUG] Sending request..." if ENV['DEBUG']
+        
+        socket.write(json_data)
         socket.write("\n")
         socket.flush
+        
+        STDERR.puts "[DEBUG] Request sent, waiting for response..." if ENV['DEBUG']
 
-        # Read response
-        response_data = socket.gets
+        # Read response - handle large responses by reading all available data
+        response_data = ''
+        begin
+          # Read until we get a newline (end of JSON response)
+          while (chunk = socket.read_nonblock(65536)) # Read in 64KB chunks
+            response_data << chunk
+            break if response_data.include?("\n")
+          end
+        rescue IO::WaitReadable
+          IO.select([socket], nil, nil, 1)
+          retry if response_data.empty? || !response_data.include?("\n")
+        rescue EOFError
+          # Server closed connection
+        end
+        
+        STDERR.puts "[DEBUG] Response received: #{response_data&.bytesize} bytes" if ENV['DEBUG']
         socket.close
 
-        JSON.parse(response_data)
+        # Extract just the first line (the JSON response)
+        json_line = response_data.split("\n").first
+        JSON.parse(json_line) if json_line
       end
     rescue Timeout::Error
+      STDERR.puts "[DEBUG] Timeout occurred after #{timeout} seconds" if ENV['DEBUG']
       { 'success' => false, 'error' => 'Timeout', 'message' => "Request timed out after #{timeout} seconds" }
     rescue StandardError => e
+      STDERR.puts "[DEBUG] Error: #{e.class}: #{e.message}" if ENV['DEBUG']
       { 'success' => false, 'error' => e.class.name, 'message' => e.message }
     end
 

data/lib/consolle/server/console_socket_server.rb

@@ -146,18 +146,24 @@ module Consolle
       def handle_client(client)
         Thread.new do
           # Read request
+          logger.debug "[ConsoleSocketServer] Waiting for request data..." if ENV['DEBUG']
           request_data = client.gets
+          logger.debug "[ConsoleSocketServer] Received data: #{request_data&.bytesize} bytes" if ENV['DEBUG']
           return unless request_data
 
           request = JSON.parse(request_data)
           logger.debug "[ConsoleSocketServer] Request: #{request.inspect}"
+          logger.debug "[ConsoleSocketServer] Code size: #{request['code']&.bytesize} bytes" if ENV['DEBUG'] && request['code']
 
           # Process through broker
           response = @broker.process_request(request)
 
           # Send response
           begin
-            client.write(JSON.generate(response))
+            # Ensure response is properly encoded as UTF-8
+            response_json = JSON.generate(response)
+            response_json = response_json.force_encoding('UTF-8')
+            client.write(response_json)
             client.write("\n")
             client.flush
           rescue Errno::EPIPE
@@ -171,7 +177,8 @@ module Consolle
               'error' => 'InvalidRequest',
               'message' => "Invalid JSON: #{e.message}"
             }
-            client.write(JSON.generate(error_response))
+            response_json = JSON.generate(error_response).force_encoding('UTF-8')
+            client.write(response_json)
             client.write("\n")
           rescue Errno::EPIPE
             logger.debug '[ConsoleSocketServer] Client disconnected while sending JSON parse error'
@@ -187,7 +194,8 @@ module Consolle
               'error' => e.class.name,
               'message' => e.message
             }
-            client.write(JSON.generate(error_response))
+            response_json = JSON.generate(error_response).force_encoding('UTF-8')
+            client.write(response_json)
             client.write("\n")
           rescue Errno::EPIPE
             # Client disconnected while sending error response

data/lib/consolle/server/console_supervisor.rb

@@ -47,10 +47,16 @@ module Consolle
         start_watchdog
       end
 
-      def eval(code, timeout: 30)
+      def eval(code, timeout: nil)
+        # Allow timeout to be configured via environment variable
+        default_timeout = ENV['CONSOLLE_TIMEOUT'] ? ENV['CONSOLLE_TIMEOUT'].to_i : 30
+        timeout ||= default_timeout
         @mutex.synchronize do
           raise 'Console is not running' unless running?
 
+          # Record start time for execution measurement
+          start_time = Time.now
+
           # Check if this is a remote console
           is_remote = @command.include?('ssh') || @command.include?('kamal') || @command.include?('docker')
 
@@ -95,14 +101,59 @@ module Consolle
                           code.encode('UTF-8')
                         end
                       end
-          encoded_code = Base64.strict_encode64(utf8_code)
-
-          # 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
+          # For large code, use temporary file approach
+          if utf8_code.bytesize > 1000
+            logger.debug "[ConsoleSupervisor] Large code (#{utf8_code.bytesize} bytes), using temporary file approach"
+            
+            # Create temp file with unique name
+            require 'tempfile'
+            require 'securerandom'
+            
+            temp_filename = "consolle_temp_#{SecureRandom.hex(8)}.rb"
+            temp_path = if defined?(Rails) && Rails.root
+                         Rails.root.join('tmp', temp_filename).to_s
+                       else
+                         File.join(Dir.tmpdir, temp_filename)
+                       end
+            
+            # Write code to temp file
+            File.write(temp_path, utf8_code)
+            logger.debug "[ConsoleSupervisor] Wrote code to temp file: #{temp_path}"
+            
+            # Load and execute the file with timeout
+            eval_command = <<~RUBY.strip
+              begin
+                require 'timeout'
+                _temp_file = '#{temp_path}'
+                Timeout.timeout(#{timeout - 1}) do
+                  load _temp_file
+                end
+              rescue Timeout::Error => e
+                puts "Timeout::Error: Code execution timed out after #{timeout - 1} seconds"
+                nil
+              rescue Exception => e
+                puts "\#{e.class}: \#{e.message}"
+                puts e.backtrace.first(5).join("\\n") if e.backtrace
+                nil
+              ensure
+                File.unlink(_temp_file) if File.exist?(_temp_file)
+              end
+            RUBY
+            
+            @writer.puts eval_command
+            @writer.flush
+          else
+            # For smaller code, use Base64 encoding to avoid escaping issues
+            encoded_code = Base64.strict_encode64(utf8_code)
+            eval_command = "begin; require 'timeout'; Timeout.timeout(#{timeout - 1}) { eval(Base64.decode64('#{encoded_code}').force_encoding('UTF-8'), IRB.CurrentContext.workspace.binding) }; rescue Timeout::Error => e; puts \"Timeout::Error: Code execution timed out after #{timeout - 1} seconds\"; nil; rescue Exception => e; puts \"\#{e.class}: \#{e.message}\"; nil; end"
+            logger.debug "[ConsoleSupervisor] Small code (#{encoded_code.bytesize} bytes), using direct Base64 approach"
+            @writer.puts eval_command
+            @writer.flush
+          end
+          
+          logger.debug "[ConsoleSupervisor] Code preview (first 100 chars): #{utf8_code[0..100].inspect}" if ENV['DEBUG']
+          
+          logger.debug "[ConsoleSupervisor] Command sent at #{Time.now}, waiting for response..."
 
           # Collect output
           output = +''
@@ -111,17 +162,21 @@ module Consolle
           begin
             loop do
               if Time.now > deadline
+                logger.debug "[ConsoleSupervisor] Timeout reached after #{Time.now - start_time}s, output so far: #{output.bytesize} bytes"
+                logger.debug "[ConsoleSupervisor] Output content: #{output.inspect}" if ENV['DEBUG']
                 # Timeout - send Ctrl-C
                 @writer.write(CTRL_C)
                 @writer.flush
                 sleep 0.5
                 clear_buffer
+                execution_time = Time.now - start_time
                 return build_timeout_response(timeout)
               end
 
               begin
                 chunk = @reader.read_nonblock(4096)
                 output << chunk
+                logger.debug "[ConsoleSupervisor] Got #{chunk.bytesize} bytes, total output: #{output.bytesize} bytes" if ENV['DEBUG']
 
                 # Respond to cursor position request during command execution
                 if chunk.include?("\e[6n")
@@ -143,18 +198,30 @@ module Consolle
                   break
                 end
               rescue IO::WaitReadable
+                logger.debug "[ConsoleSupervisor] Waiting for data... (#{Time.now - start_time}s elapsed, output size: #{output.bytesize})" if ENV['DEBUG']
                 IO.select([@reader], nil, nil, 0.1)
               rescue Errno::EIO
                 # PTY can throw EIO when no data available
                 IO.select([@reader], nil, nil, 0.1)
               rescue EOFError
+                execution_time = Time.now - start_time
                 return build_error_response(
                   EOFError.new('Console terminated'),
-                  execution_time: nil
+                  execution_time: execution_time
                 )
               end
             end
 
+            # Check if output is too large and truncate if necessary
+            max_output_size = 100_000  # 100KB limit for output
+            truncated = false
+            
+            if output.bytesize > max_output_size
+              logger.warn "[ConsoleSupervisor] Output too large (#{output.bytesize} bytes), truncating to #{max_output_size} bytes"
+              output = output[0...max_output_size]
+              truncated = true
+            end
+            
             # Parse and return result
             parsed_result = parse_output(output, eval_command)
 
@@ -162,15 +229,22 @@ module Consolle
             logger.debug "[ConsoleSupervisor] Raw output: #{output.inspect}"
             logger.debug "[ConsoleSupervisor] Parsed result: #{parsed_result.inspect}"
 
+            # Calculate execution time
+            execution_time = Time.now - start_time
+
             # 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)
+              build_error_response(parsed_result[:exception], execution_time: execution_time)
             else
-              { success: true, output: parsed_result, execution_time: nil }
+              result = { success: true, output: parsed_result, execution_time: execution_time }
+              result[:truncated] = true if truncated
+              result[:truncated_at] = max_output_size if truncated
+              result
             end
           rescue StandardError => e
             logger.error "[ConsoleSupervisor] Eval error: #{e.message}"
-            build_error_response(e, execution_time: nil)
+            execution_time = Time.now - start_time
+            build_error_response(e, execution_time: execution_time)
           end
         end
       end
@@ -257,8 +331,10 @@ module Consolle
           # Disable pry-rails (force IRB instead of Pry)
           'DISABLE_PRY_RAILS' => '1',
 
-          # Completely disable pager
+          # Completely disable pager (critical for automation)
           'PAGER' => 'cat',           # Set pager to cat (immediate output)
+          'GEM_PAGER' => 'cat',       # Disable gem pager
+          'IRB_PAGER' => 'cat',       # Ruby 3.3+ specific pager setting
           'NO_PAGER' => '1',          # Pager disable flag
           'LESS' => '',               # Clear less pager options
 
@@ -484,6 +560,9 @@ module Consolle
 
         # Send IRB configuration commands to disable interactive features
         irb_commands = [
+          # CRITICAL: Disable pager first to prevent hanging on large outputs
+          'IRB.conf[:USE_PAGER] = false',          # Disable pager completely
+          
           # Configure custom prompt mode to eliminate continuation prompts
           'IRB.conf[:PROMPT][:CONSOLLE] = { ' \
             'AUTO_INDENT: false, ' \
@@ -494,8 +573,7 @@ module Consolle
             'RETURN: "=> %s\\n" }',
           'IRB.conf[:PROMPT_MODE] = :CONSOLLE',
 
-          # Disable interactive features
-          'IRB.conf[:USE_PAGER] = false',          # Disable pager
+          # Disable other interactive features
           'IRB.conf[:USE_COLORIZE] = false',       # Disable color output
           'IRB.conf[:USE_AUTOCOMPLETE] = false',   # Disable autocompletion
           'IRB.conf[:USE_MULTILINE] = false',      # Disable multiline editor to process code at once

data/lib/consolle/server/request_broker.rb

@@ -42,6 +42,7 @@ module Consolle
 
       def process_request(request)
         request_id = request['request_id'] || SecureRandom.uuid
+        logger.debug "[RequestBroker] Received request: #{request_id}, action: #{request['action']}" if ENV['DEBUG']
 
         # Create future for response
         future = RequestFuture.new
@@ -57,11 +58,16 @@ module Consolle
                       request: request,
                       timestamp: Time.now
                     })
+        logger.debug "[RequestBroker] Queued request: #{request_id}, queue size: #{@queue.size}" if ENV['DEBUG']
 
         # Wait for response (with timeout)
         begin
-          future.get(timeout: request['timeout'] || 30)
+          logger.debug "[RequestBroker] Waiting for response: #{request_id}, timeout: #{request['timeout'] || 30}" if ENV['DEBUG']
+          response = future.get(timeout: request['timeout'] || 30)
+          logger.debug "[RequestBroker] Got response: #{request_id}" if ENV['DEBUG']
+          response
         rescue Timeout::Error
+          logger.debug "[RequestBroker] Request timed out: #{request_id}" if ENV['DEBUG']
           {
             'success' => false,
             'error' => 'RequestTimeout',

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: consolle
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.4
 platform: ruby
 authors:
 - nacyot
 bindir: bin
 cert_chain: []
-date: 2025-07-26 00:00:00.000000000 Z
+date: 2025-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger