consolle 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 570ace84f57a8120067ddae2ce8782e530f7140984558dc1b3550614a5526225
-  data.tar.gz: 0c35ba1f9afad687526c4e213adc81b1960374af656756cb6ac052c876a0c320
+  metadata.gz: a88f6019a32aaae300dee3a3e39b1dd1084ea1e2900171d6ee02f880923e071e
+  data.tar.gz: e9c468bc8095d8197e8f70cc4c0b75d0cc8da9ba3a7b0af45573300b755e1970
 SHA512:
-  metadata.gz: a058e7974ec391a07b055b291d1d933dfb48d03850b29bdbbda926ea304146d6d7174764b9099acc24d48be144ac6ffa08b55d157cb714c9f42159dea7dd3a49
-  data.tar.gz: defc74e3bc92a8bb766fcfc3b2aad0195a76b7ac4c7748507cb323a519836976e8bb8add037785ac25c35f83fb05ace9995b4e18aa0ce3ca5324a9b0f8bcccb6
+  metadata.gz: e5c0615769edda8936547380360ed5a7beeaaeda7569ccf91322daa4658923a82cad4ad87e5ffabeca4c230e89f3d371ebcaa5eec58663b25172ee0ab8c2ba07
+  data.tar.gz: 83dd02825015e9f9e73ff48075436f459722cdc045ee4b0b8d90509c5ca91274c27af682549ef114598efcf21d90628fc460360f33a069134b0da63eeab94c81

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.7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    consolle (0.3.5)
+    consolle (0.3.7)
       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/config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Consolle
+  # Configuration loader for .consolle.yml
+  class Config
+    CONFIG_FILENAME = '.consolle.yml'
+
+    # Default prompt pattern that matches various console prompts
+    # - Custom sentinel: \u001E\u001F<CONSOLLE>\u001F\u001E
+    # - Rails app prompts: app(env)> or app(env):001>
+    # - IRB prompts: irb(main):001:0> or irb(main):001>
+    # - Generic prompts: >> or >
+    DEFAULT_PROMPT_PATTERN = /^[^\w]*(\u001E\u001F<CONSOLLE>\u001F\u001E|\w+[-_]?\w*\([^)]*\)(:\d+)?>|irb\([^)]+\):\d+:?\d*[>*]|>>|>)\s*$/
+
+    attr_reader :rails_root, :prompt_pattern, :raw_prompt_pattern
+
+    def initialize(rails_root)
+      @rails_root = rails_root
+      @config = load_config
+      @raw_prompt_pattern = @config['prompt_pattern']
+      @prompt_pattern = parse_prompt_pattern(@raw_prompt_pattern)
+    end
+
+    def self.load(rails_root)
+      new(rails_root)
+    end
+
+    # Check if a custom prompt pattern is configured
+    def custom_prompt_pattern?
+      !@raw_prompt_pattern.nil?
+    end
+
+    # Get human-readable description of expected prompt patterns
+    def prompt_pattern_description
+      if custom_prompt_pattern?
+        "Custom pattern: #{@raw_prompt_pattern}"
+      else
+        <<~DESC.strip
+          Default patterns:
+            - app(env)> or app(env):001>  (Rails console)
+            - irb(main):001:0>            (IRB)
+            - >> or >                     (Generic)
+        DESC
+      end
+    end
+
+    private
+
+    def config_path
+      File.join(@rails_root, CONFIG_FILENAME)
+    end
+
+    def load_config
+      return {} unless File.exist?(config_path)
+
+      begin
+        YAML.safe_load(File.read(config_path)) || {}
+      rescue Psych::SyntaxError => e
+        warn "[Consolle] Warning: Failed to parse #{CONFIG_FILENAME}: #{e.message}"
+        {}
+      end
+    end
+
+    def parse_prompt_pattern(pattern_string)
+      return DEFAULT_PROMPT_PATTERN if pattern_string.nil?
+
+      begin
+        Regexp.new(pattern_string)
+      rescue RegexpError => e
+        warn "[Consolle] Warning: Invalid prompt_pattern '#{pattern_string}': #{e.message}"
+        warn "[Consolle] Using default pattern instead."
+        DEFAULT_PROMPT_PATTERN
+      end
+    end
+  end
+end

data/lib/consolle/errors.rb

@@ -32,6 +32,63 @@ 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
+
+    # Prompt detection failure with diagnostic information
+    class PromptDetectionError < Error
+      attr_reader :received_output, :expected_patterns, :config_path
+
+      def initialize(timeout:, received_output:, expected_patterns:, config_path:)
+        @received_output = received_output
+        @expected_patterns = expected_patterns
+        @config_path = config_path
+
+        super(build_message(timeout))
+      end
+
+      private
+
+      def build_message(timeout)
+        # Extract last line that looks like a prompt (ends with > or similar)
+        lines = @received_output.to_s.lines.map(&:strip).reject(&:empty?)
+        potential_prompt = lines.reverse.find { |l| l.match?(/[>*]\s*$/) } || lines.last
+
+        <<~MSG.strip
+          Prompt not detected after #{timeout} seconds
+
+          Received output:
+            #{@received_output.to_s.lines.last(5).map { |l| l.strip }.join("\n    ")}
+
+          Potential prompt found:
+            #{potential_prompt.inspect}
+
+          #{@expected_patterns}
+
+          To fix this, add to #{@config_path}:
+            prompt_pattern: '#{escape_for_yaml(potential_prompt)}'
+
+          Or set environment variable:
+            CONSOLLE_PROMPT_PATTERN='#{escape_for_yaml(potential_prompt)}' cone start
+        MSG
+      end
+
+      def escape_for_yaml(str)
+        return '' if str.nil?
+        # Escape special regex characters and create a simple pattern
+        str.to_s
+           .gsub(/\e\[[\d;]*[a-zA-Z]/, '') # Remove ANSI codes
+           .gsub(/[\x00-\x1F]/, '')        # Remove control characters
+           .strip
+           .gsub(/(\d+)/, '\d+')           # Replace numbers with \d+
+           .gsub(/([().\[\]{}|*+?^$\\])/, '\\\\\1') # Escape regex special chars
+      end
+    end
+
     # Syntax error in executed code
     class SyntaxError < ExecutionError
       def initialize(message)
@@ -72,7 +129,9 @@ module Consolle
         'RuntimeError' => 'RUNTIME_ERROR',
         '::RuntimeError' => 'RUNTIME_ERROR',
         'StandardError' => 'STANDARD_ERROR',
-        'Exception' => 'EXCEPTION'
+        'Exception' => 'EXCEPTION',
+        'Consolle::Errors::ServerUnhealthy' => 'SERVER_UNHEALTHY',
+        'Consolle::Errors::PromptDetectionError' => 'PROMPT_DETECTION_ERROR'
       }.freeze
 
       def self.to_code(exception)
@@ -115,4 +174,4 @@ module Consolle
       end
     end
   end
-end
+end

data/lib/consolle/server/console_supervisor.rb

@@ -5,6 +5,7 @@ require 'timeout'
 require 'fcntl'
 require 'logger'
 require_relative '../constants'
+require_relative '../config'
 require_relative '../errors'
 
 # Ruby 3.4.0+ extracts base64 as a default gem
@@ -17,15 +18,13 @@ $VERBOSE = original_verbose
 module Consolle
   module Server
     class ConsoleSupervisor
-      attr_reader :pid, :reader, :writer, :rails_root, :rails_env, :logger
+      attr_reader :pid, :reader, :writer, :rails_root, :rails_env, :logger, :config
 
       RESTART_DELAY = 1  # seconds
       MAX_RESTARTS = 5   # within 5 minutes
       RESTART_WINDOW = 300 # 5 minutes
-      # Match various Rails console prompts
-      # Match various console prompts: custom sentinel, Rails app prompts, IRB prompts, and generic prompts
-      # Allow optional non-word characters before the prompt (e.g., Unicode symbols like ▽)
-      PROMPT_PATTERN = /^[^\w]*(\u001E\u001F<CONSOLLE>\u001F\u001E|\w+[-_]?\w*\([^)]*\)>|irb\([^)]+\):\d+:?\d*[>*]|>>|>)\s*$/
+      # Legacy constant for backward compatibility - use config.prompt_pattern instead
+      PROMPT_PATTERN = Consolle::Config::DEFAULT_PROMPT_PATTERN
       CTRL_C = "\x03"
 
       def initialize(rails_root:, rails_env: 'development', logger: nil, command: nil, wait_timeout: nil)
@@ -34,6 +33,7 @@ module Consolle
         @command = command || 'bin/rails console'
         @logger = logger || Logger.new(STDOUT)
         @wait_timeout = wait_timeout || Consolle::DEFAULT_WAIT_TIMEOUT
+        @config = Consolle::Config.load(rails_root)
         @pid = nil
         @reader = nil
         @writer = nil
@@ -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)
@@ -187,7 +227,7 @@ module Consolle
 
                 # Check if we got prompt back
                 clean = strip_ansi(output)
-                if clean.match?(PROMPT_PATTERN)
+                if clean.match?(prompt_pattern)
                   # Wait a bit for any trailing output
                   sleep 0.1
                   begin
@@ -260,6 +300,11 @@ module Consolle
         end
       end
 
+      # Returns the prompt pattern to use (custom from config or default)
+      def prompt_pattern
+        @config&.prompt_pattern || Consolle::Config::DEFAULT_PROMPT_PATTERN
+      end
+
       def stop
         @running = false
 
@@ -491,7 +536,16 @@ module Consolle
             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"
+
+            # Raise PromptDetectionError with diagnostic information
+            config_path = File.join(@rails_root || '.', Consolle::Config::CONFIG_FILENAME)
+            expected_desc = @config&.prompt_pattern_description || "Default prompt patterns"
+            raise Consolle::Errors::PromptDetectionError.new(
+              timeout: timeout,
+              received_output: strip_ansi(output),
+              expected_patterns: expected_desc,
+              config_path: config_path
+            )
           end
 
           # If we found prompt and consume_all is true, continue reading for a bit more
@@ -520,7 +574,7 @@ module Consolle
             clean = strip_ansi(output)
             # Check each line for prompt pattern
             clean.lines.each do |line|
-              if line.match?(PROMPT_PATTERN)
+              if line.match?(prompt_pattern)
                 logger.info '[ConsoleSupervisor] Found prompt!'
                 prompt_found = true
               end
@@ -607,7 +661,7 @@ module Consolle
         # Wait for prompt after configuration with reasonable timeout
         begin
           wait_for_prompt(timeout: 2, consume_all: false)
-        rescue Timeout::Error
+        rescue Timeout::Error, Consolle::Errors::PromptDetectionError
           # This can fail with some console types, but that's okay
           logger.debug '[ConsoleSupervisor] No prompt after IRB configuration, continuing'
         end
@@ -646,7 +700,7 @@ module Consolle
           end
 
           # Skip prompts (but not return values that start with =>)
-          next if line.match?(PROMPT_PATTERN) && !line.start_with?('=>')
+          next if line.match?(prompt_pattern) && !line.start_with?('=>')
 
           # Skip common IRB configuration output patterns
           if line.match?(/^(IRB\.conf|DISABLE_PRY_RAILS|Switch to inspect mode|Loading .*\.rb|nil)$/) ||

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/lib/consolle.rb

@@ -3,6 +3,7 @@
 require_relative 'consolle/version'
 require_relative 'consolle/constants'
 require_relative 'consolle/errors'
+require_relative 'consolle/config'
 require_relative 'consolle/cli'
 
 # Server components

data/rule.ko.md

@@ -20,11 +20,11 @@ Cone은 디버깅, 데이터 탐색, 그리고 개발 보조 도구로 사용됩
 
 ## Cone 서버 시작과 중지
 
-`start` 명령어로 cone을 시작할 수 있으며, `-e`로 실행 환경을 지정할 수 있습니다.
+`start` 명령어로 cone을 시작할 수 있습니다. 실행 환경 지정은 `RAILS_ENV` 환경변수를 사용합니다.
 
 ```bash
-$ cone start # 서버 시작
-$ cone start -e test # test 환경에서 console 시작
+$ cone start # 서버 시작 (RAILS_ENV가 없으면 development)
+$ RAILS_ENV=test cone start # test 환경에서 console 시작
 ```
 
 중지와 재시작 명령어도 제공합니다.
@@ -114,4 +114,35 @@ users.first
 $ cone exec -f complex_task.rb
 ```
 
-모든 방법은 세션 상태를 유지하므로 변수와 객체가 실행 간에 지속됩니다.
+모든 방법은 세션 상태를 유지하므로 변수와 객체가 실행 간에 지속됩니다.
+
+## 실행 안전장치 & 타임아웃
+
+- 기본 타임아웃: 60초
+- 타임아웃 우선순위: `CONSOLLE_TIMEOUT`(설정되고 0보다 클 때) > CLI `--timeout` > 기본값(60초)
+- 사전 Ctrl‑C(프롬프트 분리):
+  - 매 `exec` 전에 Ctrl‑C를 보내고 IRB 프롬프트를 최대 3초 대기해 깨끗한 상태를 보장합니다.
+  - 3초 내 프롬프트가 돌아오지 않으면 콘솔 하위 프로세스를 재시작하고 요청은 `SERVER_UNHEALTHY`로 실패합니다.
+  - 서버 전역 비활성화: `CONSOLLE_DISABLE_PRE_SIGINT=1 cone start`
+  - 호출 단위 제어: `--pre-sigint` / `--no-pre-sigint`
+
+### 예시
+
+```bash
+# CLI로 타임아웃 지정(환경변수 미설정 시 유효)
+cone exec 'heavy_task' --timeout 120
+
+# 최우선 타임아웃(클라이언트·서버 모두 적용)
+CONSOLLE_TIMEOUT=90 cone exec 'heavy_task'
+
+# 타임아웃 이후 복구 확인
+cone exec 'sleep 999' --timeout 2      # -> EXECUTION_TIMEOUT로 실패
+cone exec "puts :after_timeout; :ok"   # -> 정상 동작(프롬프트 복구)
+
+# 호출 단위로 사전 Ctrl‑C 비활성화
+cone exec --no-pre-sigint 'code'
+```
+
+### 에러 코드
+- `EXECUTION_TIMEOUT`: 실행한 코드가 타임아웃을 초과함
+- `SERVER_UNHEALTHY`: 사전 프롬프트 확인(3초) 실패로 콘솔 재시작, 요청 실패

data/rule.md

@@ -20,11 +20,11 @@ Existing objects also reference old code, so you need to create new ones to use
 
 ## Starting and Stopping Cone Server
 
-You can start cone with the `start` command and specify the execution environment with `-e`.
+You can start cone with the `start` command. To select the Rails environment, set the `RAILS_ENV` environment variable.
 
 ```bash
-$ cone start # Start server
-$ cone start -e test # Start console in test environment
+$ cone start # Start server (uses RAILS_ENV or defaults to development)
+$ RAILS_ENV=test cone start # Start console in test environment
 ```
 
 It also provides stop and restart commands.
@@ -114,4 +114,35 @@ 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.
+
+## Execution Safety & Timeouts
+
+- Default timeout: 60s
+- Timeout precedence: `CONSOLLE_TIMEOUT` (if set and > 0) > CLI `--timeout` > default (60s)
+- Pre-exec Ctrl-C (prompt separation):
+  - Before each `exec`, cone sends Ctrl-C and waits up to 3 seconds for the IRB prompt to ensure a clean state.
+  - If the prompt does not return in 3 seconds, the console subprocess is restarted and the request fails with `SERVER_UNHEALTHY`.
+  - Disable globally for the server: `CONSOLLE_DISABLE_PRE_SIGINT=1 cone start`
+  - Per-call control: `--pre-sigint` / `--no-pre-sigint`
+
+### Examples
+
+```bash
+# Set timeout via CLI (fallback when CONSOLLE_TIMEOUT is not set)
+cone exec 'heavy_task' --timeout 120
+
+# Highest priority timeout (applies on client and server)
+CONSOLLE_TIMEOUT=90 cone exec 'heavy_task'
+
+# Verify recovery after a timeout
+cone exec 'sleep 999' --timeout 2      # -> fails with EXECUTION_TIMEOUT
+cone exec "puts :after_timeout; :ok"   # -> should succeed (prompt recovered)
+
+# Disable pre-exec Ctrl-C for a single call
+cone exec --no-pre-sigint 'code'
+```
+
+### Error Codes
+- `EXECUTION_TIMEOUT`: The executed code exceeded its timeout.
+- `SERVER_UNHEALTHY`: The pre-exec prompt did not return within 3 seconds; the console subprocess was restarted and the request failed.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: consolle
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - nacyot
 bindir: bin
 cert_chain: []
-date: 2025-08-07 00:00:00.000000000 Z
+date: 2025-12-02 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/config.rb
 - lib/consolle/constants.rb
 - lib/consolle/errors.rb
 - lib/consolle/server/console_socket_server.rb