chocomint 1.0.0

data/lib/chocomint/console/conpty.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require "ffi"
+require_relative "../errors"
+
+module Chocomint
+  module Console
+    # Windows の擬似コンソール (ConPTY) を FFI で直接叩き、対話シェルを
+    # 本物の tty として起動するラッパー。xterm.js のバックエンドに使う。
+    #
+    # 重要な前提 (スパイク検証で判明): CreatePseudoConsole を呼ぶプロセスは
+    # 自身がコンソールにアタッチされている必要がある。コンソールを持たない
+    # プロセス (CREATE_NO_WINDOW で起動された等) から生成すると、初期 VT
+    # シーケンスは出るが子プロセスの出力が out パイプに流れてこない。
+    # そのため本クラスを使うワーカーは必ずコンソール付きで起動すること
+    # (例: 非表示ウィンドウの新規コンソール)。詳細は console_worker を参照。
+    #
+    # セキュリティ注意: 生の対話 tty は PathGuard / allowed_commands の監督外で
+    # 任意コマンドを実行できる。信頼できるローカル環境専用 (127.0.0.1 限定 +
+    # トークン認証) で使うこと。DESIGN §13 の shell 展開禁止原則の例外。
+    class ConPTY
+      # Win32 API 束縛。FFI に size/alignment を委ね、手動オフセットを排除する。
+      module Native
+        extend FFI::Library
+        ffi_lib "kernel32"
+        ffi_convention :stdcall
+
+        # STARTUPINFOW (x64)。フィールド順は Win32 定義に厳密に一致させる。
+        class StartupInfoW < FFI::Struct
+          layout(
+            :cb, :uint32,
+            :lpReserved, :pointer,
+            :lpDesktop, :pointer,
+            :lpTitle, :pointer,
+            :dwX, :uint32,
+            :dwY, :uint32,
+            :dwXSize, :uint32,
+            :dwYSize, :uint32,
+            :dwXCountChars, :uint32,
+            :dwYCountChars, :uint32,
+            :dwFillAttribute, :uint32,
+            :dwFlags, :uint32,
+            :wShowWindow, :uint16,
+            :cbReserved2, :uint16,
+            :lpReserved2, :pointer,
+            :hStdInput, :pointer,
+            :hStdOutput, :pointer,
+            :hStdError, :pointer
+          )
+        end
+
+        # STARTUPINFOEXW = STARTUPINFOW + lpAttributeList。ネストで正しいオフセットに。
+        class StartupInfoExW < FFI::Struct
+          layout :StartupInfo, StartupInfoW, :lpAttributeList, :pointer
+        end
+
+        class ProcessInformation < FFI::Struct
+          layout :hProcess, :pointer, :hThread, :pointer,
+                 :dwProcessId, :uint32, :dwThreadId, :uint32
+        end
+
+        EXTENDED_STARTUPINFO_PRESENT = 0x00080000
+        PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE = 0x00020016
+        LMEM_ZEROINIT = 0x0040
+        WAIT_TIMEOUT = 0x102
+
+        attach_function :CreatePipe, %i[pointer pointer pointer uint32], :int32
+        # COORD(80x25 等) は 4 バイトなので uint32 に X:lo16 / Y:hi16 でパックして値渡し。
+        attach_function :CreatePseudoConsole, %i[uint32 pointer pointer uint32 pointer], :long
+        attach_function :ResizePseudoConsole, %i[pointer uint32], :long
+        attach_function :ClosePseudoConsole, [:pointer], :void
+        attach_function :InitializeProcThreadAttributeList,
+                        %i[pointer uint32 uint32 pointer], :int32
+        attach_function :UpdateProcThreadAttribute,
+                        %i[pointer uint32 uintptr_t pointer size_t pointer pointer], :int32
+        attach_function :DeleteProcThreadAttributeList, [:pointer], :void
+        attach_function :CreateProcessW,
+                        %i[pointer pointer pointer pointer int32 uint32
+                           pointer pointer pointer pointer], :int32
+        attach_function :ReadFile, %i[pointer pointer uint32 pointer pointer], :int32
+        attach_function :WriteFile, %i[pointer pointer uint32 pointer pointer], :int32
+        attach_function :PeekNamedPipe,
+                        %i[pointer pointer uint32 pointer pointer pointer], :int32
+        attach_function :WaitForSingleObject, %i[pointer uint32], :uint32
+        attach_function :GetExitCodeProcess, %i[pointer pointer], :int32
+        attach_function :TerminateProcess, %i[pointer uint32], :int32
+        attach_function :CloseHandle, [:pointer], :int32
+        attach_function :GetLastError, [], :uint32
+        attach_function :LocalAlloc, %i[uint32 size_t], :pointer
+      end
+
+      class Error < Chocomint::Error; end
+
+      # 出力を UTF-8 に固定する (-NoExit で初期コマンド実行後もセッションを継続)。
+      # これをしないと OutputEncoding が環境依存になり、日本語が化ける (âââ 等)。
+      DEFAULT_SHELL = %(pwsh.exe -NoProfile -NoLogo -NoExit ) +
+                      %(-Command "[Console]::OutputEncoding=[Text.Encoding]::UTF8;) +
+                      %($OutputEncoding=[Text.Encoding]::UTF8;chcp 65001 > $null;Clear-Host")
+      STILL_ACTIVE = 259
+
+      # COORD を CreatePseudoConsole/ResizePseudoConsole 用の DWORD にパックする。
+      def self.pack_size(cols, rows)
+        (rows << 16) | cols
+      end
+
+      # 起動せずにインスタンスだけ作る。実際の起動は #open で行う。
+      # command: 起動するシェル。cwd: 作業ディレクトリ (nil で継承)。
+      def initialize(command: DEFAULT_SHELL, cols: 80, rows: 25, cwd: nil)
+        @command = command
+        @cols = cols
+        @rows = rows
+        @cwd = cwd
+        @open = false
+      end
+
+      attr_reader :cols, :rows
+
+      def open?
+        @open
+      end
+
+      # 擬似コンソールを作りシェルを起動する。二重 open は禁止。
+      def open
+        raise Error, "already open" if @open
+
+        create_pipes
+        create_pseudo_console
+        build_attribute_list
+        spawn_process
+        # 親側で不要なハンドルを閉じる。out_write を閉じないと EOF が来ない。
+        Native.CloseHandle(@out_write)
+        Native.CloseHandle(@in_read)
+        @out_write = nil
+        @in_read = nil
+        @open = true
+        self
+      end
+
+      # シェルへ書き込む (xterm.js のキー入力に相当)。バイト数を返す。
+      def write(data)
+        ensure_open
+        bytes = data.to_s.b
+        return 0 if bytes.empty?
+
+        buf = FFI::MemoryPointer.new(:uint8, bytes.bytesize)
+        buf.put_bytes(0, bytes)
+        written = FFI::MemoryPointer.new(:uint32)
+        ok = Native.WriteFile(@in_write, buf, bytes.bytesize, written, nil)
+        raise Error, "WriteFile failed (#{Native.GetLastError})" if ok.zero?
+
+        written.read(:uint32)
+      end
+
+      # 現在パイプに来ている出力をノンブロッキングで読む。無ければ "" を返す
+      # (バイナリエンコーディング; VT シーケンスを含む生ストリーム)。
+      def read_available(max = 65_536)
+        ensure_open
+        avail = FFI::MemoryPointer.new(:uint32)
+        peek_ok = Native.PeekNamedPipe(@out_read, nil, 0, nil, avail, nil)
+        # PeekNamedPipe 失敗はパイプが壊れた (子終了) とみなす。
+        return nil if peek_ok.zero?
+
+        n = avail.read(:uint32)
+        return "".b if n.zero?
+
+        want = [n, max].min
+        buf = FFI::MemoryPointer.new(:uint8, want)
+        read = FFI::MemoryPointer.new(:uint32)
+        read_ok = Native.ReadFile(@out_read, buf, want, read, nil)
+        return nil if read_ok.zero?
+
+        buf.get_bytes(0, read.read(:uint32))
+      end
+
+      # 端末サイズを変更する (xterm.js のリサイズに追従)。
+      def resize(cols, rows)
+        ensure_open
+        hr = Native.ResizePseudoConsole(@hpcon, self.class.pack_size(cols, rows))
+        raise Error, "ResizePseudoConsole failed (hr=0x#{hr.to_s(16)})" unless hr.zero?
+
+        @cols = cols
+        @rows = rows
+      end
+
+      # 子プロセスが生きているか。
+      def alive?
+        return false unless @open
+
+        code = FFI::MemoryPointer.new(:uint32)
+        return false if Native.GetExitCodeProcess(@proc_handle, code).zero?
+
+        code.read(:uint32) == STILL_ACTIVE
+      end
+
+      # 子の終了コード (まだ生きているなら nil)。
+      def exit_code
+        return nil unless @open
+
+        code = FFI::MemoryPointer.new(:uint32)
+        return nil if Native.GetExitCodeProcess(@proc_handle, code).zero?
+
+        value = code.read(:uint32)
+        value == STILL_ACTIVE ? nil : value
+      end
+
+      # 擬似コンソールとプロセスを閉じ、ハンドルを解放する。冪等。
+      def close
+        return unless @open
+
+        Native.TerminateProcess(@proc_handle, 0) if alive?
+        Native.ClosePseudoConsole(@hpcon) if @hpcon
+        Native.CloseHandle(@in_write) if @in_write
+        Native.CloseHandle(@out_read) if @out_read
+        Native.CloseHandle(@proc_handle) if @proc_handle
+        Native.DeleteProcThreadAttributeList(@attr_list) if @attr_list
+        @open = false
+        nil
+      end
+
+      private
+
+      def ensure_open
+        raise Error, "not open" unless @open
+      end
+
+      def create_pipes
+        # 公式 ConPTY サンプル準拠: パイプは継承フラグなし。ハンドルは ConPTY 属性
+        # 経由でのみ子へ渡す (CreateProcess の bInheritHandles も FALSE)。
+        in_read = FFI::MemoryPointer.new(:pointer)
+        in_write = FFI::MemoryPointer.new(:pointer)
+        out_read = FFI::MemoryPointer.new(:pointer)
+        out_write = FFI::MemoryPointer.new(:pointer)
+        raise Error, "CreatePipe(in) failed" if Native.CreatePipe(in_read, in_write, nil, 0).zero?
+        raise Error, "CreatePipe(out) failed" if Native.CreatePipe(out_read, out_write, nil, 0).zero?
+
+        @in_read = in_read.read_pointer
+        @in_write = in_write.read_pointer
+        @out_read = out_read.read_pointer
+        @out_write = out_write.read_pointer
+      end
+
+      def create_pseudo_console
+        hpc = FFI::MemoryPointer.new(:pointer)
+        hr = Native.CreatePseudoConsole(
+          self.class.pack_size(@cols, @rows), @in_read, @out_write, 0, hpc
+        )
+        raise Error, "CreatePseudoConsole failed (hr=0x#{hr.to_s(16)})" unless hr.zero?
+
+        @hpcon = hpc.read_pointer
+      end
+
+      def build_attribute_list
+        lp = FFI::MemoryPointer.new(:size_t)
+        Native.InitializeProcThreadAttributeList(nil, 1, 0, lp) # サイズ取得(1回目は失敗が正常)
+        @attr_list = Native.LocalAlloc(Native::LMEM_ZEROINIT, lp.read(:size_t))
+        raise Error, "LocalAlloc failed" if @attr_list.null?
+        if Native.InitializeProcThreadAttributeList(@attr_list, 1, 0, lp).zero?
+          raise Error, "InitializeProcThreadAttributeList failed"
+        end
+
+        # lpValue には HPCON 値そのもの(=ハンドル)を渡す。cbSize はポインタ幅。
+        ok = Native.UpdateProcThreadAttribute(
+          @attr_list, 0, Native::PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
+          @hpcon, FFI::Pointer.size, nil, nil
+        )
+        raise Error, "UpdateProcThreadAttribute failed (#{Native.GetLastError})" if ok.zero?
+      end
+
+      def spawn_process
+        si = Native::StartupInfoExW.new
+        si[:StartupInfo][:cb] = Native::StartupInfoExW.size
+        si[:lpAttributeList] = @attr_list
+        pi = Native::ProcessInformation.new
+
+        cmd_w = @command.encode("UTF-16LE").b + "\x00\x00".b
+        cmd_ptr = FFI::MemoryPointer.new(:uint8, cmd_w.bytesize)
+        cmd_ptr.put_bytes(0, cmd_w)
+        cwd_ptr = nil
+        if @cwd
+          cwd_w = @cwd.encode("UTF-16LE").b + "\x00\x00".b
+          cwd_ptr = FFI::MemoryPointer.new(:uint8, cwd_w.bytesize)
+          cwd_ptr.put_bytes(0, cwd_w)
+        end
+
+        ok = Native.CreateProcessW(
+          nil, cmd_ptr, nil, nil, 0, Native::EXTENDED_STARTUPINFO_PRESENT,
+          nil, cwd_ptr, si.pointer, pi.pointer
+        )
+        raise Error, "CreateProcessW failed (#{Native.GetLastError})" if ok.zero?
+
+        @proc_handle = pi[:hProcess]
+        Native.CloseHandle(pi[:hThread])
+      end
+    end
+  end
+end

data/lib/chocomint/console/server.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+require "base64"
+require "uri"
+require "websocket/driver"
+require_relative "worker_process"
+
+module Chocomint
+  module Console
+    # xterm.js のバックエンドとなる WebSocket サーバー。
+    #
+    # WEBrick は WebSocket 非対応なので、コンソール用途だけ独立した TCP サーバーを
+    # 別スレッド・別ポートで動かす (既存の /edit・/logs HTTP は WEBrick のまま)。
+    # 接続ごとに ConPTY ワーカー (新規コンソール付き) を spawn し、ブラウザの
+    # キー入力を tty へ、tty 出力をブラウザへ双方向に橋渡しする。
+    #
+    # セキュリティ: 生の対話 tty は監督外で任意コマンド実行が可能。bind は
+    # 127.0.0.1 固定。token を要求し (URL クエリ ?token=)、一致しなければ拒否する。
+    class Server
+      # command: 起動するシェル。cwd: 作業ディレクトリ。token: 接続に要求する共有秘密。
+      def initialize(host: "127.0.0.1", port: 8081, command: ConPTY::DEFAULT_SHELL,
+                     cwd: nil, token: nil, logger: $stderr)
+        @host = host
+        @port = port
+        @command = command
+        @cwd = cwd
+        @token = token
+        @logger = logger
+      end
+
+      # ブロッキングで待ち受ける。別スレッドで呼ぶ想定 (#start_in_thread)。
+      def start
+        server = TCPServer.new(@host, @port)
+        @logger.puts("chocomint console (ws) listening on ws://#{@host}:#{@port}/")
+        loop do
+          socket = server.accept
+          Thread.new(socket) { |s| handle_connection(s) }
+        end
+      rescue IOError, Errno::EBADF
+        # サーバーソケットが閉じられた (shutdown)。
+      end
+
+      def start_in_thread
+        Thread.new { start }
+      end
+
+      private
+
+      def handle_connection(socket)
+        conn = Connection.new(socket, command: @command, cwd: @cwd, token: @token,
+                                      logger: @logger)
+        conn.run
+      rescue StandardError => e
+        @logger.puts("console connection error: #{e.class}: #{e.message}")
+      ensure
+        socket.close rescue nil
+      end
+
+      # 1 つの WebSocket 接続を ConPTY ワーカーへ橋渡しするアダプタ。
+      class Connection
+        def initialize(socket, command:, cwd:, token:, logger:)
+          @socket = socket
+          @command = command
+          @cwd = cwd
+          @token = token
+          @logger = logger
+          @open = false
+          @worker = nil
+        end
+
+        # websocket-driver は write(String) を持つオブジェクトを要求する。
+        def write(data)
+          @socket.write(data)
+        end
+
+        def run
+          @driver = WebSocket::Driver.server(self)
+          setup_driver(@driver)
+
+          loop do
+            data = @socket.readpartial(65_536)
+            @driver.parse(data)
+          end
+        rescue EOFError, IOError, Errno::ECONNRESET
+          # クライアント切断。
+        ensure
+          @pump&.kill
+          @worker&.close
+        end
+
+        private
+
+        def setup_driver(driver)
+          # ハンドシェイクの QUERY_STRING の ?token= で認証する。失敗なら接続を閉じる。
+          driver.on(:connect) do
+            if authorized?(driver)
+              driver.start
+            else
+              @socket.close rescue nil
+            end
+          end
+
+          driver.on(:open) do
+            @open = true
+            start_worker(driver)
+          end
+
+          driver.on(:message) { |event| handle_client_message(event.data) }
+          driver.on(:close) { @worker&.close }
+          driver.on(:error) { |e| @logger.puts("console ws error: #{e.message}") }
+        end
+
+        # ハンドシェイク要求の QUERY_STRING の token が設定値と一致するか。
+        # token 未設定なら常に許可 (ローカル限定運用向け)。
+        def authorized?(driver)
+          return true if @token.nil? || @token.empty?
+
+          query = driver.env["QUERY_STRING"].to_s
+          params = (URI.decode_www_form(query).to_h rescue {})
+          params["token"] == @token
+        end
+
+        def start_worker(driver)
+          @worker = WorkerProcess.new(command: @command, cols: 80, rows: 25, cwd: @cwd).start
+          @pump = start_worker_pump(driver)
+        rescue StandardError => e
+          driver.text(JSON.generate("type" => "error", "message" => e.message))
+        end
+
+        # worker → ブラウザ: tty 出力を WebSocket テキストフレームで送る。
+        def start_worker_pump(driver)
+          Thread.new do
+            loop do
+              msg = @worker.read_message
+              if msg
+                driver.text(JSON.generate(msg))
+                break if msg["type"] == "exit"
+              elsif !@worker.alive?
+                driver.text(JSON.generate("type" => "exit", "code" => 0))
+                break
+              end
+              sleep 0.01
+            end
+          rescue StandardError
+            nil
+          end
+        end
+
+        # ブラウザ → worker: 入力・リサイズを転送する。
+        def handle_client_message(data)
+          msg = JSON.parse(data)
+          case msg["type"]
+          when "input"  then @worker&.send_input(msg["data"].to_s)
+          when "resize" then @worker&.send_resize(msg["cols"].to_i, msg["rows"].to_i)
+          end
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/chocomint/console/worker.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+require "base64"
+require_relative "conpty"
+
+module Chocomint
+  module Console
+    # ConPTY を保持し、名前付きパイプを介して親 (WorkerProcess) と対話するワーカー。
+    #
+    # ConPTY は「コンソール付きプロセス」からしか正しく動かない
+    # (chocomint-conpty メモの制約) ため、このワーカーは新規コンソール付きで
+    # spawn される。通信に stdio を使うと新規コンソールとの関連付けが壊れて
+    # ConPTY 出力が止まるため、制御通信は独立した名前付きパイプで行う。
+    #
+    # プロトコル (親 ⇄ worker、いずれも 1 行 = 1 JSON):
+    #   親 → worker: {"type":"input","data":<base64>} / {"type":"resize","cols":N,"rows":M}
+    #   worker → 親: {"type":"output","data":<base64>} / {"type":"exit","code":N}
+    class Worker
+      # c2w_name: 親→worker パイプ, w2c_name: worker→親 パイプ (親が作成済み)。
+      def initialize(command:, cols:, rows:, cwd:, c2w_name:, w2c_name:)
+        @pty = ConPTY.new(command: command, cols: cols, rows: rows, cwd: cwd)
+        @c2w_name = c2w_name
+        @w2c_name = w2c_name
+        @mutex = Mutex.new
+      end
+
+      def run
+        # 親の ConnectNamedPipe の順序 (c2w → w2c) に合わせて接続する。
+        @c2w = File.open(@c2w_name, "rb")
+        @w2c = File.open(@w2c_name, "wb")
+        @w2c.sync = true
+        @pty.open
+        reader = start_output_pump
+        while (line = @c2w.gets)
+          handle(line)
+        end
+      rescue StandardError
+        # 接続断・tty 破損等。ensure でクリーンアップする。
+      ensure
+        @pty.close if @pty.open?
+        reader&.join(1)
+        @c2w&.close
+        @w2c&.close
+      end
+
+      private
+
+      def start_output_pump
+        Thread.new do
+          loop do
+            chunk = @pty.read_available
+            if chunk.nil? # パイプ破損 = 子終了
+              emit("exit", "code" => (@pty.exit_code || 0))
+              break
+            end
+            emit("output", "data" => Base64.strict_encode64(chunk)) unless chunk.empty?
+            sleep 0.01
+          end
+        rescue StandardError => e
+          emit("error", "message" => e.message)
+        end
+      end
+
+      def handle(line)
+        msg = JSON.parse(line)
+        case msg["type"]
+        when "input"  then @pty.write(Base64.strict_decode64(msg["data"].to_s))
+        when "resize" then @pty.resize(msg["cols"].to_i, msg["rows"].to_i)
+        end
+      rescue JSON::ParserError
+        nil
+      rescue ConPTY::Error
+        nil
+      end
+
+      def emit(type, extra = {})
+        @mutex.synchronize do
+          @w2c.write(JSON.generate({ "type" => type }.merge(extra)))
+          @w2c.write("\n")
+          @w2c.flush
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end