tayo 0.2.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5fa91902d5a43f2bd8259bdd3949017b629c6f228cf68600f9b4fd238a13299
-  data.tar.gz: 66e296458abdfca8cebf3e919be4f36f06fcbb1238cefd2e441d96cc193fcdda
+  metadata.gz: a128e0d938a02268ef73d7c92f956d9f316923eaf1ba7c8827f416a738e2365f
+  data.tar.gz: 6e8c5fa59202380639d5f44dc05ea1723b3df5018a15ae9ec56bb5acf2765f58
 SHA512:
-  metadata.gz: 876880104575214b91231682c947c40a73ea233dd558644bb5d34d75e90e5b4a6046185e9e650c9a945d5d9e3d4fd77cc29a4fefbabb83d1c1f82683d2b5ce9b
-  data.tar.gz: 2955f65d56f1395e823b159cc64fd2285dfe523dae26b21ea2aa896b350c499029d9fe84908fdbfad0ffbc50734e309386f1ef2613517f087c7499205d06dc36
+  metadata.gz: 4a08ad8b3b192257dbbae0cf19f007210f70e303d7b64727eb388d1381b45ac36d9b3ff9e2441490951c37eb7732da2cd0e4e14fa771fd0b3b58685f36f05490
+  data.tar.gz: 53919de826cf6970b5cd96c9bbeda335c6346df981cd9f46b7790c8f5fb310baf2362b704477ee4a5d5f84d487260ec794ece693fc67bcebbe9d9278acd22943

data/docs/2025-11-29-cf-command-refactor.md

@@ -0,0 +1,53 @@
+# tayo cf 명령어 리팩토링
+
+**날짜**: 2025-11-29
+
+## 변경 사항
+
+### 문제점
+
+1. **흐름이 어색함**: 도메인 입력을 먼저 받고 나서 Cloudflare Zone 목록을 보여주는 순서가 비직관적
+2. **기존 레코드 확인 버그**: `check_existing_records`가 `domain_info`를 파라미터로 받지만 사용하지 않고, 항상 루트 도메인만 조회
+3. **권한 안내 오류**: DNS 편집 권한만 있으면 읽기도 가능한데, 불필요하게 읽기 권한도 안내
+
+### 해결
+
+#### 새로운 흐름
+
+```
+기존:                          변경 후:
+1. 도메인 입력                  1. 토큰 입력
+2. 토큰 입력                    2. Zone 선택
+3. Zone 선택                    3. 기존 레코드 목록 표시
+4. 기존 레코드 확인 (버그)       4. 서비스 도메인 입력
+5. DNS 레코드 설정              5. 홈서버 연결 정보 입력
+6. deploy.yml 업데이트          6. DNS 레코드 생성/수정
+7. Git 커밋                     7. deploy.yml 업데이트
+                                8. Git 커밋
+```
+
+#### 주요 변경 내용
+
+1. **`show_existing_records` 메서드 추가**
+   - Zone 전체의 A/CNAME 레코드를 조회하여 표시
+   - `get_all_dns_records` 헬퍼 메서드로 name 필터 없이 조회
+
+2. **`get_domain_input` 수정**
+   - Zone 정보를 파라미터로 받아서 활용
+   - 서브도메인 사용 여부를 먼저 질문 후 입력받음
+
+3. **`get_server_info` 메서드 분리**
+   - 기존 `setup_dns_record`에서 서버 정보 입력 로직 분리
+   - "홈서버 연결 정보" 단계로 명명
+
+4. **`setup_dns_record` 단순화**
+   - 인스턴스 변수 대신 파라미터로 데이터 전달
+   - `determine_final_domain` 로직 제거 (사용자가 직접 선택)
+
+5. **권한 안내 수정**
+   - "영역 → DNS → 읽기" 제거
+   - "영역 → DNS → 편집"만 안내
+
+## 파일 변경
+
+- `lib/tayo/commands/cf.rb`: 143 insertions, 113 deletions

data/lib/tayo/cli.rb

@@ -6,6 +6,7 @@ require_relative "commands/init"
 require_relative "commands/gh"
 require_relative "commands/cf"
 require_relative "commands/proxy"
+require_relative "commands/sqlite"
 
 module Tayo
   class CLI < Thor
@@ -29,6 +30,11 @@ module Tayo
       Commands::Proxy.new.execute
     end
 
+    desc "sqlite", "SQLite + Solid Cable 최적화 설정을 적용합니다"
+    def sqlite
+      Commands::Sqlite.new.execute
+    end
+
     desc "version", "Tayo 버전을 표시합니다"
     def version
       puts "Tayo #{VERSION}"

data/lib/tayo/commands/cf.rb

@@ -12,61 +12,78 @@ module Tayo
       def execute
         puts "☁️  Cloudflare DNS 설정을 시작합니다...".colorize(:green)
 
-        unless rails_project?
-          puts "❌ Rails 프로젝트가 아닙니다. Rails 프로젝트 루트에서 실행해주세요.".colorize(:red)
-          return
-        end
-
-        # 1. 도메인 입력받기
-        domain_info = get_domain_input
-        
-        # 2. Cloudflare 토큰 생성 페이지 열기 및 권한 안내
+        # 1. Cloudflare 토큰 생성 페이지 열기 및 권한 안내
         open_token_creation_page
-        
-        # 3. 토큰 입력받기
+
+        # 2. 토큰 입력받기
         token = get_cloudflare_token
-        
-        # 4. Cloudflare API로 도메인 목록 조회 및 선택
+
+        # 3. Cloudflare API로 도메인 목록 조회 및 선택
         selected_zone = select_cloudflare_zone(token)
-        
-        # 5. 루트 도메인 레코드 확인
-        existing_records = check_existing_records(token, selected_zone, domain_info)
-        
-        # 6. DNS 레코드 추가/수정
-        setup_dns_record(token, selected_zone, domain_info, existing_records)
-        
-        # 7. config/deploy.yml 업데이트
-        update_deploy_config(domain_info)
+
+        # 4. 기존 레코드 목록 표시
+        show_existing_records(token, selected_zone)
+
+        # 5. 서비스 도메인 입력받기
+        domain_info = get_domain_input(selected_zone)
+
+        # 6. 홈서버 연결 정보 입력받기
+        server_info = get_server_info
+
+        # 7. DNS 레코드 추가/수정
+        setup_dns_record(token, selected_zone, domain_info, server_info)
+
+        # 8. config/deploy.yml 업데이트
+        update_deploy_config(domain_info, server_info)
 
         puts "\n🎉 Cloudflare DNS 설정이 완료되었습니다!".colorize(:green)
-        
+
         # 변경사항 커밋
         commit_cloudflare_changes(domain_info)
       end
 
       private
 
-      def rails_project?
-        File.exist?("Gemfile") && File.exist?("config/application.rb")
+      def get_domain_input(zone)
+        prompt = TTY::Prompt.new
+        zone_name = zone['name']
+
+        puts "📝 서비스 도메인을 설정합니다.".colorize(:yellow)
+        puts "   선택된 Zone: #{zone_name}".colorize(:gray)
+
+        use_subdomain = prompt.yes?("서브도메인을 사용하시겠습니까? (예: app.#{zone_name})")
+
+        if use_subdomain
+          subdomain = prompt.ask("서브도메인을 입력하세요 (예: app, api, www):") do |q|
+            q.validate(/\A[a-zA-Z0-9-]+\z/, "올바른 서브도메인을 입력해주세요 (영문, 숫자, 하이픈만 가능)")
+          end
+          full_domain = "#{subdomain}.#{zone_name}"
+          { type: :subdomain, domain: full_domain, zone: zone_name, subdomain: subdomain }
+        else
+          { type: :root, domain: zone_name, zone: zone_name }
+        end
       end
 
-      def get_domain_input
+      def get_server_info
         prompt = TTY::Prompt.new
-        
-        puts "\n📝 배포할 도메인을 설정합니다.".colorize(:yellow)
-        
-        domain = prompt.ask("배포할 도메인을 입력하세요 (예: myapp.com, api.example.com):") do |q|
-          q.validate(/\A[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\z/, "올바른 도메인 형식을 입력해주세요 (예: myapp.com)")
-        end
-        
-        # 도메인이 루트인지 서브도메인인지 판단
-        parts = domain.split('.')
-        if parts.length == 2
-          { type: :root, domain: domain, zone: domain }
-        else
-          zone = parts[-2..-1].join('.')
-          { type: :subdomain, domain: domain, zone: zone, subdomain: parts[0..-3].join('.') }
+
+        puts "\n🖥️  홈서버 연결 정보를 입력합니다.".colorize(:yellow)
+
+        server_address = prompt.ask("홈서버 IP 또는 도메인을 입력하세요:") do |q|
+          q.validate(/\A.+\z/, "서버 정보를 입력해주세요")
         end
+
+        ssh_user = prompt.ask("SSH 사용자 계정을 입력하세요:", default: "root")
+
+        # IP인지 도메인인지 판단
+        is_ip = server_address.match?(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/)
+        record_type = is_ip ? 'A' : 'CNAME'
+
+        {
+          address: server_address,
+          ssh_user: ssh_user,
+          record_type: record_type
+        }
       end
 
       def open_token_creation_page
@@ -79,12 +96,10 @@ module Tayo
         puts "\n다음 권한으로 토큰을 생성해주세요:".colorize(:yellow)
         puts ""
         puts "한국어 화면:".colorize(:gray)
-        puts "• 영역 → DNS → 읽기".colorize(:white)
         puts "• 영역 → DNS → 편집".colorize(:white)
         puts "  (영역 리소스는 '모든 영역' 선택)".colorize(:gray)
         puts ""
         puts "English:".colorize(:gray)
-        puts "• Zone → DNS → Read".colorize(:white)
         puts "• Zone → DNS → Edit".colorize(:white)
         puts "  (Zone Resources: Select 'All zones')".colorize(:gray)
         puts ""
@@ -171,18 +186,53 @@ module Tayo
         exit 1
       end
 
-      def check_existing_records(token, zone, domain_info)
+      def show_existing_records(token, zone)
         puts "\n🔍 기존 DNS 레코드를 확인합니다...".colorize(:yellow)
-        
+
         zone_id = zone['id']
         zone_name = zone['name']
-        
-        # 루트 도메인의 A/CNAME 레코드 확인
-        records = get_dns_records(token, zone_id, zone_name, ['A', 'CNAME'])
-        
-        puts "기존 레코드: #{records.length}개 발견".colorize(:gray)
-        
-        return records
+
+        # Zone의 모든 A/CNAME 레코드 조회
+        records = get_all_dns_records(token, zone_id, ['A', 'CNAME'])
+
+        if records.empty?
+          puts "   등록된 A/CNAME 레코드가 없습니다.".colorize(:gray)
+        else
+          puts "   #{zone_name}의 기존 레코드:".colorize(:cyan)
+          records.each do |record|
+            puts "   • #{record['name']} → #{record['content']} (#{record['type']})".colorize(:white)
+          end
+        end
+
+        puts ""
+      end
+
+      def get_all_dns_records(token, zone_id, 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 })
+
+          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.sort_by { |r| r['name'] }
+      rescue => e
+        puts "⚠️  DNS 레코드 조회 중 오류: #{e.message}".colorize(:yellow)
+        []
       end
 
       def get_dns_records(token, zone_id, name, types)
@@ -216,73 +266,41 @@ module Tayo
         return []
       end
 
-      def setup_dns_record(token, zone, domain_info, existing_records)
+      def setup_dns_record(token, zone, domain_info, server_info)
         puts "\n⚙️  DNS 레코드를 설정합니다...".colorize(:yellow)
-        
-        # 홈서버 IP/URL 입력받기
-        prompt = TTY::Prompt.new
-        
-        server_info = prompt.ask("홈서버 IP 또는 도메인을 입력하세요:") do |q|
-          q.validate(/\A.+\z/, "서버 정보를 입력해주세요")
-        end
-        
-        # SSH 사용자 계정 입력받기
-        ssh_user = prompt.ask("SSH 사용자 계정을 입력하세요:", default: "root")
-        
-        # IP인지 도메인인지 판단
-        is_ip = server_info.match?(/\A\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\z/)
-        record_type = is_ip ? 'A' : 'CNAME'
-        
+
         zone_id = zone['id']
-        zone_name = zone['name']
-        
-        # 도메인 정보에 따라 레코드 설정
-        final_domain = determine_final_domain(domain_info, zone_name, existing_records)
-        
-        # 대상 도메인의 모든 A/CNAME 레코드 확인
-        all_records = get_dns_records(token, zone_id, final_domain[:name], ['A', 'CNAME'])
-        
-        if all_records.any?
-          existing_record = all_records.first
-          
+        target_domain = domain_info[:domain]
+        server_address = server_info[:address]
+        record_type = server_info[:record_type]
+
+        # 대상 도메인의 기존 A/CNAME 레코드 확인
+        existing_records = get_dns_records(token, zone_id, target_domain, ['A', 'CNAME'])
+
+        if existing_records.any?
+          existing_record = existing_records.first
+
           # 동일한 타입이고 같은 값이면 건너뛰기
-          if existing_record['type'] == record_type && existing_record['content'] == server_info
+          if existing_record['type'] == record_type && existing_record['content'] == server_address
             puts "✅ DNS 레코드가 이미 올바르게 설정되어 있습니다.".colorize(:green)
-            puts "   #{final_domain[:full_domain]} → #{server_info} (#{record_type} 레코드)".colorize(:gray)
+            puts "   #{target_domain} → #{server_address} (#{record_type} 레코드)".colorize(:gray)
           else
             # 타입이 다르거나 값이 다른 경우 삭제 후 재생성
             puts "⚠️  기존 레코드를 삭제하고 새로 생성합니다.".colorize(:yellow)
-            puts "   기존: #{existing_record['content']} (#{existing_record['type']}) → 새로운: #{server_info} (#{record_type})".colorize(:gray)
-            
+            puts "   기존: #{existing_record['content']} (#{existing_record['type']}) → 새로운: #{server_address} (#{record_type})".colorize(:gray)
+
             # 기존 레코드 삭제
             delete_dns_record(token, zone_id, existing_record['id'])
-            
+
             # 새 레코드 생성
-            create_dns_record(token, zone_id, final_domain[:name], record_type, server_info)
+            create_dns_record(token, zone_id, target_domain, record_type, server_address)
           end
         else
           # DNS 레코드 생성
-          create_dns_record(token, zone_id, final_domain[:name], record_type, server_info)
+          create_dns_record(token, zone_id, target_domain, record_type, server_address)
         end
-        
-        # 최종 도메인 정보 저장
-        @final_domain = final_domain[:full_domain]
-        @server_info = server_info
-        @ssh_user = ssh_user
-      end
 
-      def determine_final_domain(domain_info, zone_name, existing_records)
-        case domain_info[:type]
-        when :root
-          if existing_records.any?
-            puts "⚠️  루트 도메인에 이미 레코드가 있습니다. app.#{zone_name}을 사용합니다.".colorize(:yellow)
-            { name: "app.#{zone_name}", full_domain: "app.#{zone_name}" }
-          else
-            { name: zone_name, full_domain: zone_name }
-          end
-        when :subdomain
-          { name: domain_info[:domain], full_domain: domain_info[:domain] }
-        end
+        puts "   #{target_domain} → #{server_address}".colorize(:cyan)
       end
 
       def create_dns_record(token, zone_id, name, type, content)
@@ -340,53 +358,56 @@ module Tayo
         exit 1
       end
 
-      def update_deploy_config(domain_info)
+      def update_deploy_config(domain_info, server_info)
         puts "\n📝 배포 설정을 업데이트합니다...".colorize(:yellow)
-        
+
         config_file = "config/deploy.yml"
-        
+        final_domain = domain_info[:domain]
+        server_address = server_info[:address]
+        ssh_user = server_info[:ssh_user]
+
         unless File.exist?(config_file)
           puts "⚠️  config/deploy.yml 파일이 없습니다.".colorize(:yellow)
           return
         end
-        
+
         content = File.read(config_file)
-        
+
         # proxy.host 설정 업데이트
         if content.include?("proxy:")
-          content.gsub!(/(\s+host:\s+).*$/, "\\1#{@final_domain}")
+          content.gsub!(/(\s+host:\s+).*$/, "\\1#{final_domain}")
         else
           # proxy 섹션이 없으면 추가
-          proxy_config = "\n# Proxy configuration\nproxy:\n  ssl: true\n  host: #{@final_domain}\n"
+          proxy_config = "\n# Proxy configuration\nproxy:\n  ssl: true\n  host: #{final_domain}\n"
           content += proxy_config
         end
-        
+
         # servers 설정 업데이트
         if content.match?(/servers:\s*\n\s*web:\s*\n\s*-\s*/)
-          content.gsub!(/(\s*servers:\s*\n\s*web:\s*\n\s*-\s*)[\d.]+/, "\\1#{@server_info}")
+          content.gsub!(/(\s*servers:\s*\n\s*web:\s*\n\s*-\s*)[\d.]+/, "\\1#{server_address}")
         end
-        
+
         # ssh user 설정 업데이트
-        if @ssh_user && @ssh_user != "root"
+        if ssh_user && ssh_user != "root"
           if content.match?(/^ssh:/)
             # 기존 ssh 섹션 업데이트
-            content.gsub!(/^ssh:\s*\n\s*user:\s*\w+/, "ssh:\n  user: #{@ssh_user}")
+            content.gsub!(/^ssh:\s*\n\s*user:\s*\w+/, "ssh:\n  user: #{ssh_user}")
           else
             # ssh 섹션 추가 (accessories 섹션 앞에 추가)
             if content.match?(/^# Use accessory services/)
-              content.gsub!(/^# Use accessory services/, "# Use a different ssh user than root\nssh:\n  user: #{@ssh_user}\n\n# Use accessory services")
+              content.gsub!(/^# Use accessory services/, "# Use a different ssh user than root\nssh:\n  user: #{ssh_user}\n\n# Use accessory services")
             else
               # 파일 끝에 추가
-              content += "\n# Use a different ssh user than root\nssh:\n  user: #{@ssh_user}\n"
+              content += "\n# Use a different ssh user than root\nssh:\n  user: #{ssh_user}\n"
             end
           end
         end
-        
+
         File.write(config_file, content)
         puts "✅ config/deploy.yml이 업데이트되었습니다.".colorize(:green)
-        puts "   proxy.host: #{@final_domain}".colorize(:gray)
-        puts "   servers.web: #{@server_info}".colorize(:gray)
-        puts "   ssh.user: #{@ssh_user}".colorize(:gray) if @ssh_user && @ssh_user != "root"
+        puts "   proxy.host: #{final_domain}".colorize(:gray)
+        puts "   servers.web: #{server_address}".colorize(:gray)
+        puts "   ssh.user: #{ssh_user}".colorize(:gray) if ssh_user && ssh_user != "root"
       end
       
       def commit_cloudflare_changes(domain_info)

data/lib/tayo/commands/gh.rb

@@ -12,11 +12,6 @@ module Tayo
       def execute
         puts "🚀 GitHub 저장소 및 컨테이너 레지스트리 설정을 시작합니다...".colorize(:green)
 
-        unless rails_project?
-          puts "❌ Rails 프로젝트가 아닙니다. Rails 프로젝트 루트에서 실행해주세요.".colorize(:red)
-          return
-        end
-
         puts "\n[1/7] GitHub CLI 설치 확인".colorize(:blue)
         check_github_cli
         
@@ -50,10 +45,6 @@ module Tayo
 
       private
 
-      def rails_project?
-        File.exist?("Gemfile") && File.exist?("config/application.rb")
-      end
-
       def check_github_cli
         if system("gh --version", out: File::NULL, err: File::NULL)
           puts "✅ GitHub CLI가 이미 설치되어 있습니다.".colorize(:green)

data/lib/tayo/commands/sqlite.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require "colorize"
+require "yaml"
+
+module Tayo
+  module Commands
+    class Sqlite
+      def execute
+        puts "🗄️  SQLite 최적화 설정을 시작합니다...".colorize(:green)
+
+        unless rails_project?
+          puts "❌ Rails 프로젝트가 아닙니다. Rails 프로젝트 루트에서 실행해주세요.".colorize(:red)
+          return
+        end
+
+        unless sqlite_project?
+          puts "❌ SQLite를 사용하는 프로젝트가 아닙니다.".colorize(:red)
+          return
+        end
+
+        unless rails_8_or_higher?
+          puts "❌ Rails 8 이상이 필요합니다. (현재: Rails #{detect_rails_version || '알 수 없음'})".colorize(:red)
+          puts "   Solid Cable은 Rails 8에서 도입되었습니다.".colorize(:yellow)
+          return
+        end
+
+        puts "   Rails #{detect_rails_version} 확인됨".colorize(:gray)
+
+        add_solid_cable_gem
+        run_bundle_install
+        install_solid_cable
+        update_database_yml
+        update_cable_yml
+        create_sqlite_initializer
+        run_migrations
+        create_documentation
+
+        puts ""
+        puts "✅ SQLite + Solid Cable 최적화 설정이 완료되었습니다!".colorize(:green)
+        puts "   📄 설정 배경 문서: docs/solid-cable-sqlite-setup.md".colorize(:gray)
+      end
+
+      private
+
+      def rails_project?
+        File.exist?("Gemfile") && File.exist?("config/application.rb")
+      end
+
+      def sqlite_project?
+        return false unless File.exist?("config/database.yml")
+
+        database_yml = File.read("config/database.yml")
+        database_yml.include?("sqlite3")
+      end
+
+      def rails_8_or_higher?
+        version = detect_rails_version
+        return false unless version
+
+        major_version = version.split(".").first.to_i
+        major_version >= 8
+      end
+
+      def detect_rails_version
+        # Gemfile.lock에서 rails 버전 확인
+        if File.exist?("Gemfile.lock")
+          lockfile = File.read("Gemfile.lock")
+          if match = lockfile.match(/^\s+rails\s+\((\d+\.\d+\.\d+)/)
+            return match[1]
+          end
+        end
+
+        # Gemfile에서 확인 (edge rails 등)
+        if File.exist?("Gemfile")
+          gemfile = File.read("Gemfile")
+          # gem "rails", "~> 8.0" 형식
+          if match = gemfile.match(/gem\s+["']rails["'],\s*["']~>\s*(\d+\.\d+)["']/)
+            return "#{match[1]}.0"
+          end
+          # github: "rails/rails" (edge) - Rails 8+ 가정
+          if gemfile.match?(/gem\s+["']rails["'].*github:\s*["']rails\/rails["']/)
+            return "8.0.0 (edge)"
+          end
+        end
+
+        nil
+      end
+
+      def add_solid_cable_gem
+        puts "📦 Gemfile에 solid_cable을 추가합니다...".colorize(:yellow)
+
+        gemfile = File.read("Gemfile")
+
+        if gemfile.include?("solid_cable")
+          puts "   ℹ️  solid_cable이 이미 존재합니다.".colorize(:yellow)
+          return
+        end
+
+        # solid_cable gem 추가
+        if gemfile.include?("solid_queue")
+          # solid_queue 다음에 추가
+          gemfile.gsub!(/^gem ["']solid_queue["'].*$/) do |match|
+            "#{match}\ngem \"solid_cable\""
+          end
+        elsif gemfile.match?(/^gem ["']rails["']/)
+          # rails gem 다음에 추가
+          gemfile.gsub!(/^gem ["']rails["'].*$/) do |match|
+            "#{match}\n\n# Solid Cable - SQLite 기반 Action Cable 어댑터\ngem \"solid_cable\""
+          end
+        else
+          # 파일 끝에 추가
+          gemfile += "\n# Solid Cable - SQLite 기반 Action Cable 어댑터\ngem \"solid_cable\"\n"
+        end
+
+        File.write("Gemfile", gemfile)
+        puts "   ✅ Gemfile에 solid_cable을 추가했습니다.".colorize(:green)
+      end
+
+      def update_database_yml
+        puts "🗄️  database.yml을 업데이트합니다...".colorize(:yellow)
+
+        database_yml_path = "config/database.yml"
+        content = File.read(database_yml_path)
+
+        # 이미 cable 설정이 있는지 확인
+        if content.include?("cable:") || content.include?("cable_production:")
+          puts "   ℹ️  cable 데이터베이스가 이미 설정되어 있습니다.".colorize(:yellow)
+          return
+        end
+
+        # 기존 database.yml 파싱
+        # production 설정에 cable DB 추가
+        new_content = generate_database_yml(content)
+
+        File.write(database_yml_path, new_content)
+        puts "   ✅ database.yml에 cable 데이터베이스를 추가했습니다.".colorize(:green)
+      end
+
+      def generate_database_yml(original_content)
+        # 기존 내용 유지하면서 cable DB 추가
+        lines = original_content.lines
+
+        # production 섹션 찾기
+        production_index = lines.find_index { |line| line.match?(/^production:/) }
+
+        if production_index
+          # production 섹션 끝 찾기
+          next_section_index = lines[(production_index + 1)..].find_index { |line| line.match?(/^\w+:/) }
+          insert_index = next_section_index ? production_index + 1 + next_section_index : lines.length
+
+          cable_config = <<~YAML
+
+            # Solid Cable용 별도 데이터베이스 (WAL 모드 최적화)
+            cable_production:
+              <<: *default
+              database: storage/db/cable_production.sqlite3
+              migrations_paths: db/cable_migrate
+          YAML
+
+          lines.insert(insert_index, cable_config)
+        end
+
+        # development/test에도 추가
+        dev_index = lines.find_index { |line| line.match?(/^development:/) }
+        if dev_index
+          next_section_index = lines[(dev_index + 1)..].find_index { |line| line.match?(/^\w+:/) }
+          insert_index = next_section_index ? dev_index + 1 + next_section_index : lines.length
+
+          cable_config = <<~YAML
+
+            cable_development:
+              <<: *default
+              database: storage/db/cable_development.sqlite3
+              migrations_paths: db/cable_migrate
+          YAML
+
+          lines.insert(insert_index, cable_config)
+        end
+
+        test_index = lines.find_index { |line| line.match?(/^test:/) }
+        if test_index
+          next_section_index = lines[(test_index + 1)..].find_index { |line| line.match?(/^\w+:/) }
+          insert_index = next_section_index ? test_index + 1 + next_section_index : lines.length
+
+          cable_config = <<~YAML
+
+            cable_test:
+              <<: *default
+              database: storage/db/cable_test.sqlite3
+              migrations_paths: db/cable_migrate
+          YAML
+
+          lines.insert(insert_index, cable_config)
+        end
+
+        lines.join
+      end
+
+      def update_cable_yml
+        puts "📡 cable.yml을 업데이트합니다...".colorize(:yellow)
+
+        cable_yml_path = "config/cable.yml"
+
+        # Development는 async (단일 프로세스), Production은 solid_cable
+        cable_config = <<~YAML
+          # Solid Cable 설정 (SQLite 기반 Action Cable)
+          # Development: async 어댑터 (단일 프로세스, 콘솔 디버깅 용이)
+          # Production: solid_cable (polling_interval: 25ms, Redis 수준 RTT)
+
+          development:
+            adapter: async
+
+          test:
+            adapter: test
+
+          production:
+            adapter: solid_cable
+            connects_to:
+              database:
+                writing: cable
+            polling_interval: 0.025.seconds
+            message_retention: 1.hour
+        YAML
+
+        # 기존 파일 백업
+        if File.exist?(cable_yml_path)
+          backup_path = "#{cable_yml_path}.backup"
+          FileUtils.cp(cable_yml_path, backup_path)
+          puts "   📋 기존 cable.yml을 #{backup_path}로 백업했습니다.".colorize(:gray)
+        end
+
+        File.write(cable_yml_path, cable_config)
+        puts "   ✅ cable.yml을 Solid Cable 설정으로 업데이트했습니다.".colorize(:green)
+      end
+
+      def create_sqlite_initializer
+        puts "⚡ SQLite 최적화 initializer를 생성합니다...".colorize(:yellow)
+
+        initializer_path = "config/initializers/solid_cable_sqlite.rb"
+
+        if File.exist?(initializer_path)
+          puts "   ℹ️  initializer가 이미 존재합니다.".colorize(:yellow)
+          return
+        end
+
+        initializer_content = <<~RUBY
+          # frozen_string_literal: true
+
+          # Solid Cable SQLite 최적화 설정
+          # - WAL 모드: 읽기/쓰기 동시성 향상 (폴링과 브로드캐스트 동시 처리)
+          # - synchronous=NORMAL: 쓰기 성능 향상 (약간의 안정성 트레이드오프)
+
+          Rails.application.config.after_initialize do
+            # Cable 데이터베이스에 WAL 모드 설정
+            if defined?(SolidCable) && ActiveRecord::Base.configurations.configs_for(name: "cable")
+              ActiveRecord::Base.connected_to(role: :writing, shard: :cable) do
+                connection = ActiveRecord::Base.connection
+
+                # WAL 모드 활성화 - 읽기/쓰기 동시 처리 가능
+                connection.execute("PRAGMA journal_mode=WAL")
+
+                # synchronous=NORMAL - fsync 횟수 감소로 쓰기 성능 향상
+                connection.execute("PRAGMA synchronous=NORMAL")
+
+                # 캐시 크기 증가 (기본값의 2배)
+                connection.execute("PRAGMA cache_size=4000")
+
+                Rails.logger.info "[SolidCable] SQLite WAL 모드 최적화 적용됨"
+              rescue ActiveRecord::ConnectionNotEstablished
+                # 마이그레이션 전에는 연결이 없을 수 있음
+                Rails.logger.debug "[SolidCable] Cable 데이터베이스 연결 대기 중..."
+              end
+            end
+          end
+        RUBY
+
+        FileUtils.mkdir_p("config/initializers")
+        File.write(initializer_path, initializer_content)
+        puts "   ✅ config/initializers/solid_cable_sqlite.rb를 생성했습니다.".colorize(:green)
+      end
+
+      def run_bundle_install
+        puts "📦 bundle install을 실행합니다...".colorize(:yellow)
+
+        if system("bundle install")
+          puts "   ✅ bundle install 완료".colorize(:green)
+        else
+          puts "   ❌ bundle install 실패".colorize(:red)
+          puts "   수동으로 bundle install을 실행해주세요.".colorize(:yellow)
+          exit 1
+        end
+      end
+
+      def install_solid_cable
+        puts "🔌 Solid Cable을 설치합니다...".colorize(:yellow)
+
+        # solid_cable:install 태스크가 있는지 확인
+        if system("bin/rails solid_cable:install")
+          puts "   ✅ Solid Cable 설치 완료".colorize(:green)
+        else
+          puts "   ⚠️  solid_cable:install 태스크를 찾을 수 없습니다.".colorize(:yellow)
+          puts "   마이그레이션 파일을 직접 생성합니다...".colorize(:yellow)
+          create_cable_migration
+        end
+      end
+
+      def create_cable_migration
+        # db/cable_migrate 디렉토리 생성
+        FileUtils.mkdir_p("db/cable_migrate")
+
+        timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+        migration_path = "db/cable_migrate/#{timestamp}_create_solid_cable_messages.rb"
+
+        migration_content = <<~RUBY
+          class CreateSolidCableMessages < ActiveRecord::Migration[7.2]
+            def change
+              create_table :solid_cable_messages do |t|
+                t.binary :channel, null: false, limit: 1024
+                t.binary :payload, null: false, limit: 536870912
+                t.datetime :created_at, null: false
+                t.integer :channel_hash, null: false, limit: 8
+
+                t.index :channel
+                t.index :channel_hash
+                t.index :created_at
+              end
+            end
+          end
+        RUBY
+
+        File.write(migration_path, migration_content)
+        puts "   ✅ 마이그레이션 파일 생성: #{migration_path}".colorize(:green)
+      end
+
+      def run_migrations
+        puts "🗄️  데이터베이스를 준비합니다...".colorize(:yellow)
+
+        # storage 디렉토리 생성
+        FileUtils.mkdir_p("storage")
+
+        # db:prepare는 마이그레이션 + 스키마 로드를 모두 처리
+        if system("bin/rails db:prepare")
+          puts "   ✅ 데이터베이스 준비 완료".colorize(:green)
+        else
+          puts "   ⚠️  데이터베이스 준비 실패".colorize(:yellow)
+          puts "   수동으로 bin/rails db:prepare를 실행해주세요.".colorize(:yellow)
+        end
+      end
+
+      def create_documentation
+        puts "📄 설정 문서를 생성합니다...".colorize(:yellow)
+
+        FileUtils.mkdir_p("docs")
+        doc_path = "docs/solid-cable-sqlite-setup.md"
+
+        if File.exist?(doc_path)
+          puts "   ℹ️  문서가 이미 존재합니다.".colorize(:yellow)
+          return
+        end
+
+        # 템플릿 파일에서 문서 내용 읽기
+        template_path = File.expand_path("../../templates/solid-cable-sqlite-setup.md", __FILE__)
+        doc_content = File.read(template_path)
+
+        File.write(doc_path, doc_content)
+        puts "   ✅ docs/solid-cable-sqlite-setup.md를 생성했습니다.".colorize(:green)
+      end
+    end
+  end
+end

data/lib/tayo/templates/solid-cable-sqlite-setup.md

@@ -0,0 +1,90 @@
+# Solid Cable + SQLite 최적화 설정
+
+> 이 문서는 `tayo sqlite` 명령어로 자동 생성되었습니다.
+
+## 개요
+
+이 프로젝트는 Redis 없이 SQLite만으로 Action Cable 실시간 기능을 구현합니다.
+Rails 8에서 도입된 Solid Cable을 사용하여 WebSocket 브로드캐스트를 처리합니다.
+
+## 왜 Solid Cable인가?
+
+### Redis vs Solid Cable
+
+| 항목 | Redis | Solid Cable |
+|------|-------|-------------|
+| 의존성 | Redis 서버 필요 | DB만 사용 |
+| 방식 | Pub/Sub (푸시) | Polling (폴링) |
+| 지연시간 | ~1ms | ~25ms (설정값) |
+| 운영 복잡도 | Redis 관리 필요 | 단순 |
+
+### 체감 성능
+
+- **25ms 폴링**: 사용자가 지연을 체감하기 어려움 (200ms 이하는 "즉각적"으로 느껴짐)
+- **RTT 비교**: Redis ~80ms vs Solid Cable ~85ms (전체 왕복 시간 기준, 거의 동일)
+
+## 적용된 설정
+
+### 1. 데이터베이스 분리 (database.yml)
+
+```yaml
+production:
+  primary:
+    database: storage/production.sqlite3
+  cable:
+    database: storage/production_cable.sqlite3  # 별도 DB
+```
+
+**이유**: Cable 폴링이 메인 DB의 쓰기 작업과 락 경합하지 않도록 분리
+
+### 2. Cable 설정 (cable.yml)
+
+```yaml
+development:
+  adapter: async  # 단일 프로세스, 콘솔 디버깅 용이
+
+production:
+  adapter: solid_cable
+  polling_interval: 0.025.seconds  # 25ms
+  message_retention: 1.hour
+```
+
+**폴링 간격 선택 기준**:
+- 100ms: 기본값, 대부분 충분
+- 25ms: 채팅/실시간 앱에 적합
+- 10ms: Redis 수준, 부하 증가
+
+### 3. SQLite WAL 모드 최적화 (initializer)
+
+```ruby
+# config/initializers/solid_cable_sqlite.rb
+PRAGMA journal_mode=WAL      # 읽기/쓰기 동시 처리
+PRAGMA synchronous=NORMAL    # 쓰기 성능 향상
+PRAGMA cache_size=4000       # 캐시 증가
+```
+
+**WAL 모드 장점**:
+- 읽기(폴링)와 쓰기(브로드캐스트)가 동시에 가능
+- Solid Cable의 폴링 패턴에 최적화
+
+## 성능 가이드
+
+### 적정 사용 범위
+
+| 동시 접속 | 메시지/초 | 예상 지연 |
+|----------|----------|----------|
+| ~50명 | ~10 | 거의 없음 |
+| ~100명 | ~20 | ~50ms |
+| ~500명 | ~100 | 검토 필요 |
+
+### 스케일 아웃이 필요한 경우
+
+- 초당 200개 이상 메시지
+- 1000명 이상 동시 접속
+- → Redis 또는 PostgreSQL NOTIFY 고려
+
+## 참고 자료
+
+- [Solid Cable GitHub](https://github.com/rails/solid_cable)
+- [SQLite WAL Mode](https://sqlite.org/wal.html)
+- [Rails 8 Release Notes](https://rubyonrails.org/2024/11/7/rails-8-no-paas-required)

data/lib/tayo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tayo
-  VERSION = "0.2.0"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tayo
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.3
 platform: ruby
 authors:
 - 이원섭wonsup Lee/Alfonso
@@ -92,6 +92,7 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
+- docs/2025-11-29-cf-command-refactor.md
 - exe/tayo
 - lib/tayo.rb
 - lib/tayo/cli.rb
@@ -99,12 +100,14 @@ files:
 - lib/tayo/commands/gh.rb
 - lib/tayo/commands/init.rb
 - lib/tayo/commands/proxy.rb
+- lib/tayo/commands/sqlite.rb
 - lib/tayo/dockerfile_modifier.rb
 - lib/tayo/proxy/cloudflare_client.rb
 - lib/tayo/proxy/docker_manager.rb
 - lib/tayo/proxy/network_config.rb
 - lib/tayo/proxy/traefik_config.rb
 - lib/tayo/proxy/welcome_service.rb
+- lib/tayo/templates/solid-cable-sqlite-setup.md
 - lib/tayo/version.rb
 - lib/templates/welcome/Dockerfile
 - lib/templates/welcome/index.html