consolle 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 570ace84f57a8120067ddae2ce8782e530f7140984558dc1b3550614a5526225
-  data.tar.gz: 0c35ba1f9afad687526c4e213adc81b1960374af656756cb6ac052c876a0c320
+  metadata.gz: 9b3d8a284ca63f38a9e02ca394141f50cd4c0d02a63bae7f78d384a027d0c400
+  data.tar.gz: 7ddfdc210a765e4fc8c6598e5b2d38ffe78f2997a4811c55f6bf461862ccba0a
 SHA512:
-  metadata.gz: a058e7974ec391a07b055b291d1d933dfb48d03850b29bdbbda926ea304146d6d7174764b9099acc24d48be144ac6ffa08b55d157cb714c9f42159dea7dd3a49
-  data.tar.gz: defc74e3bc92a8bb766fcfc3b2aad0195a76b7ac4c7748507cb323a519836976e8bb8add037785ac25c35f83fb05ace9995b4e18aa0ce3ca5324a9b0f8bcccb6
+  metadata.gz: ce17c1df36c8284f051bfd658e63252846547e0886cbe4330005470ce4997f24334a470196de0310f24cccf7f305b4c358985752d301cc76a9514d15c296feb5
+  data.tar.gz: 93ff0d888e2436be4cc2952508e6b8dba29afdd79303434e0126871022c23f67de70cccbfc0c8e7e33c0d853c2f90aaf8c2be61f6d3e0559ee8694b195b85807

data/.gitignore

@@ -3,4 +3,6 @@ tmp/
 .gem/
 *.gem
 .notes/
-cone-examples.md
+cone-examples.md
+vendor/
+.bundle/

data/.version

@@ -1 +1 @@
-0.3.5
+0.3.6

data/Gemfile.lock

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

data/README.md

@@ -8,7 +8,7 @@ Consolle is a library that manages Rails console through PTY (Pseudo-Terminal).
 - **Socket Server Architecture**: Stable client-server communication through Unix socket
 - **Automatic Restart (Watchdog)**: Automatic recovery on process failure
 - **Environment-specific Execution**: Supports Rails environments (development, test, production)
-- **Timeout Handling**: Automatic termination of infinite loops and long-running code
+- **Timeout Handling**: Automatic termination of long-running code with robust prompt recovery
 - **Log Management**: Automatic management of execution history and session logs
 
 ## Installation
@@ -50,17 +50,46 @@ cone restart
 ### Advanced Usage
 
 ```bash
-# Start with specific environment
-cone start -e test
+# Start with specific environment (use RAILS_ENV)
+RAILS_ENV=test cone start
 
-# Restart with environment change
-cone restart -e production
+# Restart with environment change (use RAILS_ENV)
+RAILS_ENV=production cone restart
 
 # Force full server restart
 cone restart --force
 
-# Set timeout
-cone exec "sleep 10" --timeout 5
+# Set timeout (default: 60s; precedence: CONSOLLE_TIMEOUT > --timeout > defaults)
+CONSOLLE_TIMEOUT=90 cone exec "long_running_task"   # env wins
+cone exec "long_running_task" --timeout 120         # falls back when env not set
+
+# Pre-exec Ctrl-C (prompt separation)
+By default (development/production), cone sends Ctrl-C before each `exec` and waits for the IRB prompt (up to 3 seconds) to ensure a clean state and avoid hanging on partial input. If the prompt does not return within 3 seconds, the console subprocess is force-restarted and the request fails with `SERVER_UNHEALTHY`, so the caller can retry.
+
+Timeout precedence
+- `CONSOLLE_TIMEOUT` (if set and > 0) overrides all other sources on both client and server.
+- Otherwise, CLI `--timeout` is used.
+- Otherwise, default of 60s applies.
+
+- Per‑call control (CLI):
+  - Enable: `cone exec --pre-sigint 'code'`
+  - Disable: `cone exec --no-pre-sigint 'code'`
+- Global (server‑wide) control via environment when starting the server:
+  - Disable: `CONSOLLE_DISABLE_PRE_SIGINT=1 cone start`
+  - Note: this env var is read by the server process at start time, not by `cone exec`.
+
+# Timeout and interrupt behavior during execution
+- On execution timeout, cone sends Ctrl‑C to interrupt and attempts prompt recovery. For local consoles, it also sends an OS‑level `SIGINT` as a fallback.
+- After recovery, subsequent `cone exec` requests continue normally.
+
+# Error codes
+- `EXECUTION_TIMEOUT`: The executed code exceeded its timeout.
+- `SERVER_UNHEALTHY`: Pre‑exec prompt did not return within 3 seconds; the console subprocess was restarted and the request failed.
+
+# Examples
+- Force an execution timeout quickly and verify recovery:
+  - `cone exec 'sleep 999' --timeout 2` → fails with `EXECUTION_TIMEOUT`
+  - `cone exec 'puts :after_timeout; :ok'` → should succeed (`:ok`)
 
 # Verbose log output
 cone -v exec "User.all"
@@ -120,7 +149,7 @@ Consolle consists of the following structure:
 - Manages Rails console process through PTY
 - Automatic restart (Watchdog) feature
 - Environment variable settings and IRB automation configuration
-- Timeout handling and Ctrl-C support
+- Timeout handling and Ctrl-C support (pre-exec safety check + post-timeout recovery)
 
 #### RequestBroker
 - Ensures request order through serial queue
@@ -145,6 +174,11 @@ env = {
 }
 ```
 
+Additional environment variables
+
+- `CONSOLLE_TIMEOUT`: Highest‑priority timeout (seconds). Overrides CLI `--timeout` and defaults on both client and server.
+- `CONSOLLE_DISABLE_PRE_SIGINT=1`: Disable the pre‑exec Ctrl‑C prompt check at the server level (read when starting the server).
+
 ## File Locations
 
 - **Socket file**: `{Rails.root}/tmp/cone/cone.socket`
@@ -187,4 +221,4 @@ ls ~/.cone/sessions/
 
 - **Current version**: 0.1.0
 - **Ruby version**: 3.0 or higher
-- **Rails version**: 7.0 or higher
+- **Rails version**: 7.0 or higher

data/lib/consolle/adapters/rails_console.rb

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

data/lib/consolle/cli.rb

@@ -50,7 +50,7 @@ module Consolle
           shell.say
           shell.say 'EXAMPLES:', :yellow
           shell.say "  cone exec 'User.count'                    # Execute code in default session"
-          shell.say "  cone start -t api -e production           # Start production console named 'api'"
+          shell.say "  RAILS_ENV=production cone start           # Start console in production"
           shell.say "  cone exec -t api 'Rails.env'              # Execute code in 'api' session"
           shell.say '  cone exec -f script.rb                    # Execute code from file'
           shell.say
@@ -121,8 +121,8 @@ module Consolle
       The console runs as a daemon and can be accessed through the exec command.
 
       You can specify a custom session name with --target to run multiple consoles:
-        cone start --target api --rails_env production
-        cone start --target worker --rails_env development
+        RAILS_ENV=production cone start --target api
+        RAILS_ENV=development cone start --target worker
 
       Custom console commands are supported for special environments:
         cone start --command "kamal app exec -i 'bin/rails console'"
@@ -131,7 +131,7 @@ module Consolle
       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'
+    # Rails environment is now controlled via RAILS_ENV, not a CLI option
     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
@@ -160,7 +160,7 @@ module Consolle
         clear_session_info
       end
 
-      adapter = create_rails_adapter(options[:rails_env], options[:target], options[:command], options[:wait_timeout])
+      adapter = create_rails_adapter(current_rails_env, options[:target], options[:command], options[:wait_timeout])
 
       puts 'Starting Rails console...'
 
@@ -175,7 +175,7 @@ module Consolle
 
         # Log session start
         log_session_event(adapter.process_pid, 'session_start', {
-                            rails_env: options[:rails_env],
+                            rails_env: current_rails_env,
                             socket_path: adapter.socket_path
                           })
       rescue StandardError => e
@@ -197,7 +197,7 @@ module Consolle
       end
 
       # Check if server is actually responsive
-      adapter = create_rails_adapter('development', options[:target])
+      adapter = create_rails_adapter(current_rails_env, options[:target])
       server_status = begin
         adapter.get_status
       rescue StandardError
@@ -255,7 +255,7 @@ module Consolle
         # Check if process is alive
         if info['process_pid'] && process_alive?(info['process_pid'])
           # Try to get server status
-          adapter = create_rails_adapter('development', name)
+      adapter = create_rails_adapter(current_rails_env, name)
           server_status = begin
             adapter.get_status
           rescue StandardError
@@ -390,13 +390,12 @@ module Consolle
         cone restart -t api
         cone restart --target worker --force
     LONGDESC
-    method_option :rails_env, type: :string, aliases: '-e', desc: 'Rails environment', default: 'development'
     method_option :force, type: :boolean, aliases: '-f', desc: 'Force restart the entire server'
     def restart
       ensure_rails_project!
       validate_session_name!(options[:target])
 
-      adapter = create_rails_adapter(options[:rails_env], options[:target])
+      adapter = create_rails_adapter(current_rails_env, options[:target])
 
       if adapter.running?
         # Check if environment needs to be changed
@@ -406,25 +405,20 @@ module Consolle
           nil
         end
         current_env = current_status&.dig('rails_env') || 'development'
-        needs_full_restart = options[:force] || (current_env != options[:rails_env])
+        desired_env = current_rails_env
+        needs_full_restart = options[:force] || (current_env != desired_env)
 
         if needs_full_restart
-          if current_env != options[:rails_env]
-            puts "Environment change detected (#{current_env} -> #{options[:rails_env]})"
+          if current_env != desired_env
+            puts "Environment change detected (#{current_env} -> #{desired_env})"
             puts 'Performing full server restart...'
           else
             puts 'Force restarting Rails console server...'
           end
 
-          # Save current rails_env for start command
-          old_env = @rails_env
-          @rails_env = options[:rails_env]
-
           stop
           sleep 1
-          invoke(:start, [], { rails_env: options[:rails_env] })
-
-          @rails_env = old_env
+          invoke(:start)
         else
           puts 'Restarting Rails console subprocess...'
 
@@ -459,7 +453,7 @@ module Consolle
         end
       else
         puts 'Rails console is not running. Starting it...'
-        invoke(:start, [], { rails_env: options[:rails_env] })
+        invoke(:start)
       end
     end
 
@@ -484,7 +478,8 @@ module Consolle
       #{'  '}
       The console must be started first with 'cone start'.
     LONGDESC
-    method_option :timeout, type: :numeric, desc: 'Timeout in seconds', default: 30
+    method_option :timeout, type: :numeric, desc: 'Timeout in seconds', default: 60
+    method_option :pre_sigint, type: :boolean, desc: 'Send Ctrl-C before executing code (experimental)'
     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)
@@ -548,7 +543,13 @@ module Consolle
       puts "Executing: #{code}" if options[:verbose]
 
       # Send code to socket
-      result = send_code_to_socket(session_info[:socket_path], code, timeout: options[:timeout])
+      send_opts = { timeout: options[:timeout] }
+      send_opts[:pre_sigint] = options[:pre_sigint] unless options[:pre_sigint].nil?
+      result = send_code_to_socket(
+        session_info[:socket_path],
+        code,
+        **send_opts
+      )
 
       # Log the request and response
       log_session_activity(session_info[:process_pid], code, result)
@@ -583,6 +584,10 @@ module Consolle
 
     private
 
+    def current_rails_env
+      ENV['RAILS_ENV'] || 'development'
+    end
+
     def ensure_rails_project!
       return if File.exist?('config/environment.rb') || File.exist?('config/application.rb')
 
@@ -621,21 +626,27 @@ module Consolle
       File.join(Dir.pwd, 'tmp', 'cone', "#{target}.log")
     end
 
-    def send_code_to_socket(socket_path, code, timeout: 30)
+    def send_code_to_socket(socket_path, code, timeout: 60, pre_sigint: nil)
       request_id = SecureRandom.uuid
       # Ensure code is UTF-8 encoded
       code = code.force_encoding('UTF-8') if code.respond_to?(:force_encoding)
       
+      # CONSOLLE_TIMEOUT takes highest priority on client side if present and > 0
+      env_timeout = ENV['CONSOLLE_TIMEOUT']&.to_i
+      effective_timeout = (env_timeout && env_timeout > 0) ? env_timeout : timeout
+
       request = {
         'action' => 'eval',
         'code' => code,
-        'timeout' => timeout,
+        'timeout' => effective_timeout,
         'request_id' => request_id
       }
+      # Include pre_sigint flag only when explicitly provided (true/false)
+      request['pre_sigint'] = pre_sigint unless pre_sigint.nil?
 
       STDERR.puts "[DEBUG] Creating socket connection to: #{socket_path}" if ENV['DEBUG']
       
-      Timeout.timeout(timeout + 5) do
+      Timeout.timeout(effective_timeout + 5) do
         socket = UNIXSocket.new(socket_path)
         STDERR.puts "[DEBUG] Socket connected" if ENV['DEBUG']
 
@@ -680,8 +691,8 @@ module Consolle
         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" }
+      STDERR.puts "[DEBUG] Timeout occurred after #{effective_timeout} seconds" if ENV['DEBUG']
+      { 'success' => false, 'error' => 'Timeout', 'message' => "Request timed out after #{effective_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 }

data/lib/consolle/errors.rb

@@ -32,6 +32,13 @@ module Consolle
     # Execution errors
     class ExecutionError < Error; end
 
+    # Server/console health issues
+    class ServerUnhealthy < Error
+      def initialize(message = 'Console server is unhealthy')
+        super(message)
+      end
+    end
+
     # Syntax error in executed code
     class SyntaxError < ExecutionError
       def initialize(message)
@@ -72,7 +79,8 @@ module Consolle
         'RuntimeError' => 'RUNTIME_ERROR',
         '::RuntimeError' => 'RUNTIME_ERROR',
         'StandardError' => 'STANDARD_ERROR',
-        'Exception' => 'EXCEPTION'
+        'Exception' => 'EXCEPTION',
+        'Consolle::Errors::ServerUnhealthy' => 'SERVER_UNHEALTHY'
       }.freeze
 
       def self.to_code(exception)
@@ -115,4 +123,4 @@ module Consolle
       end
     end
   end
-end
+end

data/lib/consolle/server/console_supervisor.rb

@@ -47,10 +47,14 @@ module Consolle
         start_watchdog
       end
 
-      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
+      def eval(code, timeout: nil, pre_sigint: nil)
+        # CONSOLLE_TIMEOUT has highest priority if present and > 0
+        env_timeout = ENV['CONSOLLE_TIMEOUT']&.to_i
+        timeout = if env_timeout && env_timeout > 0
+                    env_timeout
+                  else
+                    timeout || 60
+                  end
         @mutex.synchronize do
           raise 'Console is not running' unless running?
 
@@ -60,22 +64,40 @@ module Consolle
           # Check if this is a remote console
           is_remote = @command.include?('ssh') || @command.include?('kamal') || @command.include?('docker')
 
-          if is_remote
-            # Send Ctrl-C to ensure clean state before execution
+          # Decide whether to send pre-exec Ctrl-C
+          # Default: enabled for all consoles to avoid getting stuck mid-input.
+          # Opt-out via param or ENV `CONSOLLE_DISABLE_PRE_SIGINT=1`.
+          disable_pre_sigint = ENV['CONSOLLE_DISABLE_PRE_SIGINT'] == '1'
+          default_pre_sigint = (@rails_env != 'test')
+          do_pre_sigint = if pre_sigint.nil?
+                            default_pre_sigint && !disable_pre_sigint
+                          else
+                            pre_sigint
+                          end
+
+          if do_pre_sigint
+            # Send Ctrl-C to ensure clean state before execution, then wait up to 3s for prompt.
+            # If prompt doesn't come back, consider server unhealthy, force-restart the subprocess,
+            # and return an error so the caller can retry after recovery.
             @writer.write(CTRL_C)
             @writer.flush
-
-            # Clear any pending output
-            clear_buffer
-
-            # Wait for prompt after Ctrl-C
+            # Nudge IRB and force prompt emission with a trivial probe
+            @writer.puts "puts '__consolle_probe__'"
+            @writer.flush
             begin
-              wait_for_prompt(timeout: 1, consume_all: true)
+              wait_for_prompt(timeout: 3, consume_all: true)
             rescue Timeout::Error
-              # Continue anyway, some consoles may not show prompt immediately
+              logger.error '[ConsoleSupervisor] No prompt after pre-exec Ctrl-C (3s). Forcing console restart.'
+              # Forcefully stop subprocess so watchdog can restart
+              @process_mutex.synchronize do
+                stop_console
+              end
+              # Return an unhealthy error to the caller
+              err = Consolle::Errors::ServerUnhealthy.new('No prompt after pre-exec interrupt (3s); console restarted')
+              return build_error_response(err, execution_time: 0)
             end
           else
-            # For local consoles, just clear buffer
+            # For local consoles without pre-sigint, clear buffer only
             clear_buffer
           end
 
@@ -164,10 +186,28 @@ module Consolle
               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
+                # Timeout - try to interrupt current execution and recover prompt
+                3.times do |i|
+                  @writer.write(CTRL_C)
+                  @writer.flush
+                  logger.debug "[ConsoleSupervisor] Sent Ctrl-C (attempt #{i + 1})"
+                  begin
+                    wait_for_prompt(timeout: 1.0, consume_all: true)
+                    logger.debug '[ConsoleSupervisor] Prompt recovered after Ctrl-C'
+                    break
+                  rescue Timeout::Error
+                    # As a fallback for local consoles, send OS-level SIGINT to the subprocess
+                    unless is_remote
+                      begin
+                        Process.kill('INT', @pid)
+                        logger.warn '[ConsoleSupervisor] Sent OS-level SIGINT to subprocess'
+                      rescue StandardError => e
+                        logger.warn "[ConsoleSupervisor] Failed to send OS-level SIGINT: #{e.message}"
+                      end
+                    end
+                  end
+                end
+                # Final cleanup
                 clear_buffer
                 execution_time = Time.now - start_time
                 return build_timeout_response(timeout)

data/lib/consolle/server/request_broker.rb

@@ -62,8 +62,10 @@ module Consolle
 
         # Wait for response (with timeout)
         begin
-          logger.debug "[RequestBroker] Waiting for response: #{request_id}, timeout: #{request['timeout'] || 30}" if ENV['DEBUG']
-          response = future.get(timeout: request['timeout'] || 30)
+          env_timeout = ENV['CONSOLLE_TIMEOUT']&.to_i
+          future_timeout = (env_timeout && env_timeout > 0) ? env_timeout : (request['timeout'] || 30)
+          logger.debug "[RequestBroker] Waiting for response: #{request_id}, timeout: #{future_timeout}" if ENV['DEBUG']
+          response = future.get(timeout: future_timeout)
           logger.debug "[RequestBroker] Got response: #{request_id}" if ENV['DEBUG']
           response
         rescue Timeout::Error
@@ -157,7 +159,8 @@ module Consolle
 
       def process_eval_request(request)
         code = request['code']
-        timeout = request['timeout'] || 30
+        env_timeout = ENV['CONSOLLE_TIMEOUT']&.to_i
+        timeout = (env_timeout && env_timeout > 0) ? env_timeout : (request['timeout'] || 30)
 
         unless code
           return {
@@ -168,7 +171,11 @@ module Consolle
         end
 
         # Execute through supervisor
-        result = @supervisor.eval(code, timeout: timeout)
+        if request.key?('pre_sigint')
+          result = @supervisor.eval(code, timeout: timeout, pre_sigint: request['pre_sigint'])
+        else
+          result = @supervisor.eval(code, timeout: timeout)
+        end
 
         # Format response
         if result[:success]

data/rule.ko.md

@@ -24,7 +24,7 @@ Cone은 디버깅, 데이터 탐색, 그리고 개발 보조 도구로 사용됩
 
 ```bash
 $ cone start # 서버 시작
-$ cone start -e test # test 환경에서 console 시작
+$ RAILS_ENV=test cone start # test 환경에서 console 시작
 ```
 
 중지와 재시작 명령어도 제공합니다.
@@ -114,4 +114,4 @@ users.first
 $ cone exec -f complex_task.rb
 ```
 
-모든 방법은 세션 상태를 유지하므로 변수와 객체가 실행 간에 지속됩니다.
+모든 방법은 세션 상태를 유지하므로 변수와 객체가 실행 간에 지속됩니다.

data/rule.md

@@ -24,7 +24,7 @@ You can start cone with the `start` command and specify the execution environmen
 
 ```bash
 $ cone start # Start server
-$ cone start -e test # Start console in test environment
+$ RAILS_ENV=test cone start # Start console in test environment
 ```
 
 It also provides stop and restart commands.
@@ -114,4 +114,4 @@ For complex multi-line code, save it in a file:
 $ cone exec -f complex_task.rb
 ```
 
-All methods maintain the session state, so variables and objects persist between executions.
+All methods maintain the session state, so variables and objects persist between executions.

metadata

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