tayo 0.2.3 → 0.3.0

data/lib/tayo/proxy/cloudflare_client.rb

@@ -1,323 +0,0 @@
-# frozen_string_literal: true
-
-require "colorize"
-require "tty-prompt"
-require "net/http"
-require "json"
-require "uri"
-require "fileutils"
-
-module Tayo
-  module Proxy
-    class CloudflareClient
-      TOKEN_FILE = File.expand_path("~/.tayo/cloudflare_token")
-
-      def initialize
-        @prompt = TTY::Prompt.new
-      end
-
-      def ensure_token
-        @token = load_saved_token
-
-        if @token
-          puts "🔑 저장된 Cloudflare 토큰을 확인합니다...".colorize(:yellow)
-
-          if test_token(@token)
-            puts "✅ 저장된 Cloudflare 토큰이 유효합니다.".colorize(:green)
-          else
-            puts "⚠️  저장된 토큰이 만료되었거나 유효하지 않습니다.".colorize(:yellow)
-            puts "새 토큰을 입력해주세요.".colorize(:cyan)
-            open_token_creation_page
-            @token = get_cloudflare_token
-            save_token(@token)
-          end
-        else
-          puts "\n🔑 Cloudflare API 토큰이 필요합니다.".colorize(:yellow)
-          open_token_creation_page
-          @token = get_cloudflare_token
-          save_token(@token)
-        end
-      end
-
-      def select_domains
-        puts "\n🌐 Cloudflare 도메인 목록을 조회합니다...".colorize(:yellow)
-
-        zones = get_cloudflare_zones
-
-        if zones.empty?
-          puts "❌ Cloudflare에 등록된 도메인이 없습니다.".colorize(:red)
-          puts "먼저 https://dash.cloudflare.com 에서 도메인을 추가해주세요.".colorize(:cyan)
-          return []
-        end
-
-        zone_choices = zones.map { |zone| "#{zone['name']} (#{zone['status']})" }
-
-        selected_zones = @prompt.multi_select(
-          "Caddy로 라우팅할 도메인을 선택하세요 (Space로 선택, Enter로 완료):",
-          zone_choices,
-          per_page: 10,
-          min: 1
-        )
-
-        # 선택된 항목이 없으면 빈 배열 반환
-        return [] if selected_zones.nil? || selected_zones.empty?
-
-        puts "DEBUG: selected_zones = #{selected_zones.inspect}" if ENV["DEBUG"]
-
-        selected_domains = selected_zones.map do |selection|
-          zone_name = selection.split(' ').first
-          zone = zones.find { |z| z['name'] == zone_name }
-
-          # 서브도메인 추가 여부 확인
-          if @prompt.yes?("#{zone_name}에 서브도메인을 추가하시겠습니까?")
-            subdomain = @prompt.ask("서브도메인을 입력하세요 (예: app, api):")
-            if subdomain && !subdomain.empty?
-              {
-                domain: "#{subdomain}.#{zone_name}",
-                zone_id: zone['id'],
-                zone_name: zone_name
-              }
-            else
-              {
-                domain: zone_name,
-                zone_id: zone['id'],
-                zone_name: zone_name
-              }
-            end
-          else
-            {
-              domain: zone_name,
-              zone_id: zone['id'],
-              zone_name: zone_name
-            }
-          end
-        end
-
-        puts "\n✅ 선택된 도메인:".colorize(:green)
-        selected_domains.each do |d|
-          puts "   • #{d[:domain]}".colorize(:cyan)
-        end
-
-        puts "DEBUG: returning selected_domains = #{selected_domains.inspect}" if ENV["DEBUG"]
-
-        selected_domains
-      end
-
-      def setup_dns_records(domains, public_ip)
-        domains.each do |domain_info|
-          domain = domain_info[:domain]
-          zone_id = domain_info[:zone_id]
-
-          puts "\n⚙️  #{domain}의 DNS 레코드를 설정합니다...".colorize(:yellow)
-
-          # 기존 A 레코드 확인
-          existing_records = get_dns_records(zone_id, domain, ['A'])
-
-          if existing_records.any?
-            existing_record = existing_records.first
-            if existing_record['content'] == public_ip
-              puts "✅ #{domain} → #{public_ip} (이미 설정됨)".colorize(:green)
-            else
-              puts "⚠️  기존 레코드를 업데이트합니다.".colorize(:yellow)
-              update_dns_record(zone_id, existing_record['id'], public_ip)
-            end
-          else
-            # 새 A 레코드 생성
-            create_dns_record(zone_id, domain, 'A', public_ip)
-          end
-        end
-      end
-
-      private
-
-      def load_saved_token
-        return nil unless File.exist?(TOKEN_FILE)
-        File.read(TOKEN_FILE).strip
-      rescue
-        nil
-      end
-
-      def save_token(token)
-        dir = File.dirname(TOKEN_FILE)
-
-        # 디렉토리가 파일로 존재하는 경우 삭제
-        if File.exist?(dir) && !File.directory?(dir)
-          FileUtils.rm(dir)
-        end
-
-        # 디렉토리가 없을 때만 생성
-        FileUtils.mkdir_p(dir) unless File.directory?(dir)
-
-        File.write(TOKEN_FILE, token)
-        File.chmod(0600, TOKEN_FILE)
-        puts "✅ API 토큰이 저장되었습니다.".colorize(:green)
-      end
-
-      def open_token_creation_page
-        puts "토큰 생성 페이지를 엽니다...".colorize(:cyan)
-        system("open 'https://dash.cloudflare.com/profile/api-tokens' 2>/dev/null || xdg-open 'https://dash.cloudflare.com/profile/api-tokens' 2>/dev/null")
-
-        puts "\n다음 권한으로 토큰을 생성해주세요:".colorize(:yellow)
-        puts ""
-        puts "한국어 화면:".colorize(:gray)
-        puts "• 영역 → 영역 → 읽기".colorize(:white)
-        puts "• 영역 → DNS → 편집".colorize(:white)
-        puts "  (영역 리소스는 '모든 영역' 선택)".colorize(:gray)
-        puts ""
-        puts "English:".colorize(:gray)
-        puts "• Zone → Zone → Read".colorize(:white)
-        puts "• Zone → DNS → Edit".colorize(:white)
-        puts "  (Zone Resources: Select 'All zones')".colorize(:gray)
-        puts ""
-      end
-
-      def get_cloudflare_token
-        token = @prompt.mask("생성된 Cloudflare API 토큰을 붙여넣으세요:")
-
-        if token.nil? || token.strip.empty?
-          puts "❌ 토큰이 입력되지 않았습니다.".colorize(:red)
-          exit 1
-        end
-
-        if test_token(token.strip)
-          puts "✅ 토큰이 확인되었습니다.".colorize(:green)
-          return token.strip
-        else
-          puts "❌ 토큰이 올바르지 않거나 권한이 부족합니다.".colorize(:red)
-          exit 1
-        end
-      end
-
-      def test_token(token)
-        uri = URI('https://api.cloudflare.com/client/v4/user/tokens/verify')
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        request = Net::HTTP::Get.new(uri)
-        request['Authorization'] = "Bearer #{token}"
-        request['Content-Type'] = 'application/json'
-
-        response = http.request(request)
-
-        if response.code == '200'
-          data = JSON.parse(response.body)
-          return data['success'] == true
-        else
-          return false
-        end
-      rescue => e
-        puts "⚠️  토큰 검증 중 오류: #{e.message}".colorize(:yellow) if ENV["DEBUG"]
-        false
-      end
-
-      def get_cloudflare_zones
-        uri = URI('https://api.cloudflare.com/client/v4/zones')
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        request = Net::HTTP::Get.new(uri)
-        request['Authorization'] = "Bearer #{@token}"
-        request['Content-Type'] = 'application/json'
-
-        response = http.request(request)
-
-        if response.code == '200'
-          data = JSON.parse(response.body)
-          return data['result'] || []
-        else
-          puts "❌ 도메인 목록 조회에 실패했습니다: #{response.code}".colorize(:red)
-          []
-        end
-      rescue => e
-        puts "❌ API 요청 중 오류가 발생했습니다: #{e.message}".colorize(:red)
-        []
-      end
-
-      def get_dns_records(zone_id, name, types)
-        records = []
-
-        types.each do |type|
-          uri = URI("https://api.cloudflare.com/client/v4/zones/#{zone_id}/dns_records")
-          uri.query = URI.encode_www_form({
-            type: type,
-            name: name
-          })
-
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-
-          request = Net::HTTP::Get.new(uri)
-          request['Authorization'] = "Bearer #{@token}"
-          request['Content-Type'] = 'application/json'
-
-          response = http.request(request)
-
-          if response.code == '200'
-            data = JSON.parse(response.body)
-            records.concat(data['result'] || [])
-          end
-        end
-
-        records
-      rescue => e
-        puts "⚠️  DNS 레코드 조회 중 오류: #{e.message}".colorize(:yellow)
-        []
-      end
-
-      def create_dns_record(zone_id, name, type, content)
-        uri = URI("https://api.cloudflare.com/client/v4/zones/#{zone_id}/dns_records")
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        request = Net::HTTP::Post.new(uri)
-        request['Authorization'] = "Bearer #{@token}"
-        request['Content-Type'] = 'application/json'
-
-        data = {
-          type: type,
-          name: name,
-          content: content,
-          ttl: 300,
-          proxied: false
-        }
-
-        request.body = data.to_json
-        response = http.request(request)
-
-        if response.code == '200'
-          puts "✅ #{name} → #{content} (A 레코드 생성됨)".colorize(:green)
-        else
-          puts "❌ DNS 레코드 생성 실패: #{response.code}".colorize(:red)
-          puts response.body if ENV["DEBUG"]
-        end
-      rescue => e
-        puts "❌ DNS 레코드 생성 중 오류: #{e.message}".colorize(:red)
-      end
-
-      def update_dns_record(zone_id, record_id, new_content)
-        uri = URI("https://api.cloudflare.com/client/v4/zones/#{zone_id}/dns_records/#{record_id}")
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        request = Net::HTTP::Patch.new(uri)
-        request['Authorization'] = "Bearer #{@token}"
-        request['Content-Type'] = 'application/json'
-
-        data = {
-          content: new_content
-        }
-
-        request.body = data.to_json
-        response = http.request(request)
-
-        if response.code == '200'
-          puts "✅ DNS 레코드가 업데이트되었습니다.".colorize(:green)
-        else
-          puts "❌ DNS 레코드 업데이트 실패: #{response.code}".colorize(:red)
-        end
-      rescue => e
-        puts "❌ DNS 레코드 업데이트 중 오류: #{e.message}".colorize(:red)
-      end
-    end
-  end
-end

data/lib/tayo/proxy/docker_manager.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require "colorize"
-require "json"
-
-module Tayo
-  module Proxy
-    class DockerManager
-      def check_containers
-        puts "\n🐳 Docker 컨테이너 상태를 확인합니다...".colorize(:yellow)
-
-        unless docker_installed?
-          puts "❌ Docker가 설치되어 있지 않습니다.".colorize(:red)
-          puts "https://www.docker.com/get-started 에서 Docker를 설치해주세요.".colorize(:cyan)
-          exit 1
-        end
-
-        unless docker_running?
-          puts "❌ Docker가 실행되고 있지 않습니다.".colorize(:red)
-          puts "Docker Desktop을 실행해주세요.".colorize(:cyan)
-          exit 1
-        end
-
-        # Kamal Proxy 상태 확인
-        check_kamal_proxy_status
-
-        # Caddy 상태 확인
-        check_caddy_status
-
-        puts ""
-      end
-
-      def container_exists?(name)
-        output = `docker ps -a --filter "name=^#{name}$" --format "{{.Names}}" 2>/dev/null`.strip
-        !output.empty?
-      end
-
-      def container_running?(name)
-        output = `docker ps --filter "name=^#{name}$" --format "{{.Names}}" 2>/dev/null`.strip
-        !output.empty?
-      end
-
-      def check_port_binding(container, ports)
-        return false unless container_running?(container)
-
-        ports.all? do |port|
-          output = `docker port #{container} #{port} 2>/dev/null`.strip
-          !output.empty?
-        end
-      end
-
-      def port_in_use?(port)
-        # Docker 컨테이너가 포트를 사용 중인지 확인
-        docker_using = `docker ps --format "table {{.Names}}\t{{.Ports}}" | grep -E "0\\.0\\.0\\.0:#{port}->|\\*:#{port}->" 2>/dev/null`.strip
-        return true unless docker_using.empty?
-
-        # 시스템 포트 확인
-        if RUBY_PLATFORM.include?("darwin")
-          # macOS
-          output = `lsof -iTCP:#{port} -sTCP:LISTEN 2>/dev/null`.strip
-        else
-          # Linux
-          output = `netstat -tln 2>/dev/null | grep ":#{port}"`.strip
-          output = `ss -tln 2>/dev/null | grep ":#{port}"`.strip if output.empty?
-        end
-
-        !output.empty?
-      end
-
-      def stop_container(name)
-        return unless container_exists?(name)
-
-        puts "🛑 #{name} 컨테이너를 중지합니다...".colorize(:yellow)
-        system("docker stop #{name} >/dev/null 2>&1")
-        system("docker rm #{name} >/dev/null 2>&1")
-      end
-
-      def get_container_network(name)
-        return nil unless container_running?(name)
-
-        output = `docker inspect #{name} --format '{{range .NetworkSettings.Networks}}{{.NetworkID}}{{end}}' 2>/dev/null`.strip
-        output.empty? ? nil : output
-      end
-
-      def create_network_if_not_exists(network_name = "tayo-proxy")
-        existing = `docker network ls --filter "name=^#{network_name}$" --format "{{.Name}}" 2>/dev/null`.strip
-
-        if existing.empty?
-          puts "📡 Docker 네트워크 '#{network_name}'를 생성합니다...".colorize(:yellow)
-          system("docker network create #{network_name} >/dev/null 2>&1")
-        end
-
-        network_name
-      end
-
-      private
-
-      def docker_installed?
-        system("which docker >/dev/null 2>&1")
-      end
-
-      def docker_running?
-        system("docker info >/dev/null 2>&1")
-      end
-
-      def check_kamal_proxy_status
-        # Traefik으로 교체되어 더 이상 사용하지 않음
-        check_traefik_status
-      end
-
-      def check_traefik_status
-        if container_running?("traefik")
-          if check_port_binding("traefik", [80, 443])
-            puts "✅ Traefik: 실행 중 (80, 443 포트 사용)".colorize(:green)
-          else
-            puts "⚠️  Traefik: 실행 중이지만 포트가 올바르게 바인딩되지 않음".colorize(:yellow)
-            show_port_conflicts
-          end
-        elsif container_exists?("traefik")
-          puts "⚠️  Traefik: 중지됨".colorize(:yellow)
-        else
-          puts "ℹ️  Traefik: 설치되지 않음".colorize(:gray)
-        end
-      end
-
-      def check_caddy_status
-        # Caddy는 더 이상 사용하지 않음
-        # 이 메서드는 하위 호환성을 위해 유지하지만 아무것도 하지 않음
-      end
-
-      def show_port_conflicts
-        [80, 443].each do |port|
-          if port_in_use?(port)
-            # 포트를 사용 중인 프로세스 찾기
-            if RUBY_PLATFORM.include?("darwin")
-              process = `lsof -iTCP:#{port} -sTCP:LISTEN 2>/dev/null | grep LISTEN | head -1`.strip
-            else
-              process = `netstat -tlnp 2>/dev/null | grep ":#{port}" | head -1`.strip
-            end
-
-            unless process.empty?
-              puts "   ⚠️  포트 #{port}가 다른 프로세스에서 사용 중입니다:".colorize(:yellow)
-              puts "      #{process}".colorize(:gray)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/tayo/proxy/network_config.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require "colorize"
-require "tty-prompt"
-
-module Tayo
-  module Proxy
-    class NetworkConfig
-      attr_reader :public_ip, :internal_ip, :external_http, :external_https
-
-      def initialize
-        @prompt = TTY::Prompt.new
-        @use_custom_ports = false
-      end
-
-      def detect_ips
-        puts "\n🔍 네트워크 정보를 확인합니다...".colorize(:yellow)
-
-        # 공인 IP 감지
-        print "공인 IP 확인 중... "
-        @public_ip = detect_public_ip
-        puts "#{@public_ip}".colorize(:green)
-
-        # 내부 IP 감지
-        print "내부 IP 확인 중... "
-        @internal_ip = detect_internal_ip
-        puts "#{@internal_ip}".colorize(:green)
-
-        puts ""
-      end
-
-      def configure_ports
-        puts "\n🌐 외부 접속 포트를 설정합니다.".colorize(:yellow)
-        puts "Kamal Proxy는 항상 80, 443 포트를 사용합니다.".colorize(:gray)
-        puts ""
-
-        choices = [
-          { name: "공유기에서 80, 443을 직접 포워딩 (기본)", value: :direct },
-          { name: "다른 포트를 사용하여 포워딩 (예: 8080→80, 8443→443)", value: :custom }
-        ]
-
-        choice = @prompt.select("포트 설정 방식을 선택하세요:", choices)
-
-        if choice == :custom
-          @use_custom_ports = true
-
-          @external_http = @prompt.ask("HTTP 외부 포트 (기본: 8080):", default: "8080")
-          @external_https = @prompt.ask("HTTPS 외부 포트 (기본: 8443):", default: "8443")
-
-          puts "\n✅ 외부 포트가 설정되었습니다:".colorize(:green)
-          puts "   HTTP:  #{@external_http}".colorize(:gray)
-          puts "   HTTPS: #{@external_https}".colorize(:gray)
-        else
-          @external_http = "80"
-          @external_https = "443"
-
-          puts "\n✅ 표준 포트(80, 443)를 사용합니다.".colorize(:green)
-        end
-      end
-
-      def use_custom_ports?
-        @use_custom_ports
-      end
-
-      def show_port_forwarding_guide
-        return unless use_custom_ports?
-
-        puts "\n📡 공유기 포트포워딩 설정 안내:".colorize(:yellow)
-        puts "━" * 50
-        puts "외부 포트 #{@external_http} → #{@internal_ip}:80".colorize(:white)
-        puts "외부 포트 #{@external_https} → #{@internal_ip}:443".colorize(:white)
-        puts "━" * 50
-        puts ""
-        puts "위 설정을 공유기 관리 페이지에서 완료해주세요.".colorize(:cyan)
-        puts "일반적인 접속 주소: http://192.168.1.1".colorize(:gray)
-      end
-
-      private
-
-      def detect_public_ip
-        # curl을 사용한 공인 IP 감지
-        ip = `curl -s ifconfig.me 2>/dev/null`.strip
-
-        # 대체 방법들
-        if ip.empty? || !valid_ip?(ip)
-          ip = `curl -s ipecho.net/plain 2>/dev/null`.strip
-        end
-
-        if ip.empty? || !valid_ip?(ip)
-          ip = `curl -s icanhazip.com 2>/dev/null`.strip
-        end
-
-        if ip.empty? || !valid_ip?(ip)
-          puts "\n⚠️  공인 IP를 자동으로 감지할 수 없습니다.".colorize(:yellow)
-          ip = @prompt.ask("공인 IP를 직접 입력해주세요:") do |q|
-            q.validate(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/, "올바른 IP 형식을 입력해주세요")
-          end
-        end
-
-        ip
-      end
-
-      def detect_internal_ip
-        # macOS
-        if RUBY_PLATFORM.include?("darwin")
-          # en0 (Wi-Fi) 또는 en1 (Ethernet) 인터페이스에서 IP 추출
-          ip = `ifconfig en0 2>/dev/null | grep 'inet ' | grep -v 127.0.0.1 | awk '{print $2}'`.strip
-          ip = `ifconfig en1 2>/dev/null | grep 'inet ' | grep -v 127.0.0.1 | awk '{print $2}'`.strip if ip.empty?
-
-          # 다른 인터페이스 검색
-          if ip.empty?
-            ip = `ifconfig | grep 'inet ' | grep -v 127.0.0.1 | grep -v '::1' | head -1 | awk '{print $2}'`.strip
-          end
-        else
-          # Linux
-          ip = `hostname -I 2>/dev/null | awk '{print $1}'`.strip
-
-          if ip.empty?
-            ip = `ip addr show | grep 'inet ' | grep -v 127.0.0.1 | grep -v '::1' | head -1 | awk '{print $2}' | cut -d/ -f1`.strip
-          end
-        end
-
-        # 여전히 비어있다면 수동 입력
-        if ip.empty? || !valid_ip?(ip)
-          puts "\n⚠️  내부 IP를 자동으로 감지할 수 없습니다.".colorize(:yellow)
-          ip = @prompt.ask("내부 IP를 직접 입력해주세요 (예: 192.168.1.100):") do |q|
-            q.validate(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/, "올바른 IP 형식을 입력해주세요")
-          end
-        end
-
-        ip
-      end
-
-      def valid_ip?(ip)
-        return false if ip.nil? || ip.empty?
-
-        parts = ip.split('.')
-        return false unless parts.length == 4
-
-        parts.all? do |part|
-          num = part.to_i
-          num >= 0 && num <= 255 && part == num.to_s
-        end
-      end
-    end
-  end
-end