rails-console 0.1.0

data/app/assets/rails_console/src/application.css

@@ -0,0 +1,12 @@
+html,
+body {
+  background: #000;
+  height: 100%;
+  margin: 0;
+  padding: 0;
+}
+
+#rails-console {
+  height: 100vh;
+  width: 100vw;
+}

data/app/assets/rails_console/src/console.js

@@ -0,0 +1,135 @@
+import { createConsumer } from '@rails/actioncable';
+import { FitAddon } from '@xterm/addon-fit';
+import { Terminal } from '@xterm/xterm';
+
+const RELOAD_MARKER = '\x00CONSOLE_RELOAD\x00';
+const RETRY_DELAY = 3000;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const SPINNER_INTERVAL = 90;
+
+class RailsConsoleTerminal {
+  constructor(element) {
+    this.element = element;
+    this.consumer = createConsumer();
+  }
+
+  connect() {
+    this.openTerminal();
+    this.subscribe();
+  }
+
+  disconnect() {
+    window.removeEventListener('resize', this.onResize);
+
+    clearTimeout(this.retryTimeout);
+    this.stopSpinner();
+
+    this.subscription?.unsubscribe();
+    this.terminal?.dispose();
+  }
+
+  onData(data) {
+    const bytes = new TextEncoder().encode(data);
+    const binary = String.fromCharCode(...bytes);
+
+    this.subscription.perform('receive', { bytes: btoa(binary) });
+  }
+
+  openTerminal() {
+    this.fitAddon = new FitAddon();
+    this.terminal = new Terminal({ cursorBlink: true });
+
+    this.terminal.loadAddon(this.fitAddon);
+    this.terminal.open(this.element);
+    this.fitAddon.fit();
+    this.terminal.focus();
+
+    this.onResize = () => this.fitAddon.fit();
+
+    window.addEventListener('resize', this.onResize);
+
+    this.terminal.onData((data) => this.onData(data));
+  }
+
+  received(data) {
+    if (data.error) {
+      this.stopSpinner();
+      this.showError(data.error);
+    } else if (data.bytes) {
+      this.writeBytes(data.bytes);
+    }
+  }
+
+  showError(message) {
+    this.terminal.write(`\r\n${message}\r\n`);
+
+    this.subscription.unsubscribe();
+
+    this.retryTimeout = setTimeout(() => this.subscribe(), RETRY_DELAY);
+  }
+
+  startSpinner() {
+    let frame = 0;
+
+    this.spinner = setInterval(() => {
+      this.terminal.write(`\r\x1b[K\x1b[33m${SPINNER_FRAMES[frame]}\x1b[0m Booting console…`);
+
+      frame = (frame + 1) % SPINNER_FRAMES.length;
+    }, SPINNER_INTERVAL);
+  }
+
+  stopSpinner() {
+    if (!this.spinner) {
+      return;
+    }
+
+    clearInterval(this.spinner);
+
+    this.spinner = null;
+
+    this.terminal.write('\r\x1b[K');
+  }
+
+  subscribe() {
+    this.startSpinner();
+
+    this.subscription = this.consumer.subscriptions.create('RailsConsole::ConsoleChannel', {
+      connected: () => {},
+      disconnected: () => {},
+      received: (data) => this.received(data),
+    });
+  }
+
+  writeBytes(encoded) {
+    let binary = atob(encoded);
+
+    // The broker sends this marker when it swaps the session (e.g. on unsafe!). Reset the
+    // screen and show the booting spinner again until the fresh console prints its output.
+    if (binary.includes(RELOAD_MARKER)) {
+      binary = binary.replaceAll(RELOAD_MARKER, '');
+
+      this.terminal.reset();
+      this.startSpinner();
+    } else {
+      this.stopSpinner();
+    }
+
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+
+    this.terminal.write(bytes);
+  }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+  const element = document.querySelector('[data-rails-console]');
+
+  if (!element) {
+    return;
+  }
+
+  const terminal = new RailsConsoleTerminal(element);
+
+  terminal.connect();
+
+  window.addEventListener('beforeunload', () => terminal.disconnect());
+});

data/app/channels/rails_console/console_channel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'socket'
+
+module RailsConsole
+  class ConsoleChannel < ActionCable::Channel::Base
+    # Keystrokes from the browser: decode and forward them to the broker.
+    def receive(data)
+      bytes = Base64.strict_decode64(data.fetch('bytes'))
+
+      @socket&.write(bytes)
+    rescue ArgumentError, Errno::EPIPE, IOError
+      nil
+    end
+
+    # Connects an authorized user to the broker and starts streaming its output back.
+    def subscribed
+      return reject if !RailsConsole.authorized?(connection)
+
+      return reject_unavailable if !RailsConsole::Broker.boot
+
+      @socket = connect_to_broker
+      @reader_thread = Thread.new { relay_broker_output }
+    rescue Errno::ECONNREFUSED, Errno::ENOENT
+      reject_unavailable
+    end
+
+    # Closes the broker connection when the browser leaves.
+    def unsubscribed
+      @reader_thread&.kill
+      @socket&.close
+    rescue IOError
+      nil
+    end
+
+    private
+
+    # Opens the broker socket and sends who is connecting.
+    def connect_to_broker
+      socket = UNIXSocket.new(RailsConsole.socket_path.to_s)
+      identity = RailsConsole.config.current_user.call(RailsConsole.user_from(connection))
+      ip_address = Rack::Request.new(connection.env).ip
+      label = identity[:label] || identity['label']
+      user_id = identity[:id] || identity['id']
+
+      socket.puts(JSON.generate(ip_address:, label:, user_id:))
+
+      socket
+    end
+
+    # Tells the browser the console could not be reached and drops the subscription.
+    def reject_unavailable
+      transmit({ error: 'Console is unavailable at the moment.' })
+
+      reject
+    end
+
+    # Streams broker output to the browser, encoded so binary bytes survive JSON.
+    def relay_broker_output
+      loop do
+        bytes = @socket.readpartial(RailsConsole::PtySession::READ_SIZE)
+
+        transmit({ bytes: Base64.strict_encode64(bytes) })
+      end
+    rescue IOError
+      nil
+    end
+  end
+end

data/app/controllers/rails_console/consoles_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RailsConsole
+  class ConsolesController < ActionController::Base
+    layout 'rails_console/application'
+
+    before_action :authorize!
+
+    def show; end
+
+    private
+
+    def authorize!
+      return if RailsConsole.authorized?(request)
+
+      head(403)
+    end
+  end
+end

data/app/models/rails_console/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RailsConsole
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/rails_console/log_line.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RailsConsole
+  class LogLine < ApplicationRecord
+    self.table_name = 'rails_console_log_lines'
+
+    enum :direction, { input: 0, output: 1, transition: 2 }
+
+    belongs_to :session, class_name: 'RailsConsole::Session', inverse_of: :log_lines, optional: false
+
+    validates :content, presence: true
+  end
+end

data/app/models/rails_console/session.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsConsole
+  class Session < ApplicationRecord
+    self.table_name = 'rails_console_sessions'
+
+    has_many :log_lines, class_name: 'RailsConsole::LogLine', dependent: :destroy, inverse_of: :session
+
+    validates :started_at, presence: true
+
+    def user
+      return if RailsConsole.user_class.blank?
+
+      model = RailsConsole.user_class.safe_constantize
+
+      return if model.nil?
+
+      model.find_by(id: user_id)
+    end
+  end
+end

data/app/views/layouts/rails_console/application.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Rails Console</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <%= csrf_meta_tags %>
+    <%= action_cable_meta_tag %>
+
+    <%= stylesheet_link_tag 'rails_console', nonce: true %>
+    <%= javascript_include_tag 'rails_console', nonce: true %>
+  </head>
+
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/app/views/rails_console/consoles/show.html.erb

@@ -0,0 +1 @@
+<div id="rails-console" data-rails-console></div>

data/bin/rails_console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+abort('Run this from a Rails app root (bundle exec rails_console).') if !File.exist?('config/environment.rb')
+
+require File.expand_path('config/environment', Dir.pwd)
+
+RailsConsole::Broker.new.run

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+RailsConsole::Engine.routes.draw do
+  root to: 'consoles#show'
+end

data/lib/generators/rails_console/install_generator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RailsConsole
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    desc 'Installs RailsConsole migrations and initializer'
+
+    def create_initializer
+      template('rails_console.rb', 'config/initializers/rails_console.rb')
+    end
+
+    def create_migrations
+      template(
+        'db/migrate/create_rails_console_sessions.rb',
+        "db/migrate/#{timestamp(0)}_create_rails_console_sessions.rb"
+      )
+
+      template(
+        'db/migrate/create_rails_console_log_lines.rb',
+        "db/migrate/#{timestamp(1)}_create_rails_console_log_lines.rb"
+      )
+    end
+
+    def link_sprockets_assets
+      manifest = 'app/assets/config/manifest.js'
+
+      return if !File.exist?(manifest)
+
+      contents = File.read(manifest)
+
+      return if contents.include?('rails_console.css')
+
+      append_to_file(manifest) do
+        <<~JS
+
+          //= link rails_console.css
+          //= link rails_console.js
+        JS
+      end
+    end
+
+    private
+
+    def migration_version
+      ActiveRecord::Migration.current_version
+    rescue StandardError
+      '8.1'
+    end
+
+    def timestamp(offset)
+      Time.current.utc.strftime('%Y%m%d%H%M%S').to_i + offset
+    end
+  end
+end

data/lib/generators/rails_console/templates/db/migrate/create_rails_console_log_lines.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateRailsConsoleLogLines < ActiveRecord::Migration[<%= migration_version %>]
+  def change
+    create_table :rails_console_log_lines do |t|
+      t.integer :direction, null: false, default: 0
+      t.text :content, null: false
+
+      t.references :session, foreign_key: { to_table: :rails_console_sessions }, null: false
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/rails_console/templates/db/migrate/create_rails_console_sessions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateRailsConsoleSessions < ActiveRecord::Migration[<%= migration_version %>]
+  def change
+    create_table :rails_console_sessions do |t|
+      t.integer :user_id
+      t.string :user_label
+      t.string :ip_address
+      t.datetime :started_at, null: false
+      t.datetime :ended_at
+      t.datetime :unsafe_at
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/rails_console/templates/rails_console.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RailsConsole.configure do |config|
+  config.audit = true
+
+  config.authorize = ->(user) { user&.devops? }
+
+  config.command = 'bundle exec rails console'
+
+  config.current_user = ->(user) { { id: user&.id, label: user.try(:email) || 'unknown' } }
+
+  config.idle_timeout = 10.minutes
+  config.sandbox_command = 'bundle exec rails console --sandbox'
+end