Update app.py

app.py

@@ -1,266 +1,571 @@
-import gradio as gr
+#!/usr/bin/env python3
+"""
+HF Space Auto-Deployer
+----------------------
+공개 Git 레포지토리를 Hugging Face Gradio Space로 자동 변환 및 배포합니다.
+
+필요 환경변수:
+- BAPI_TOKEN: Brave Search API Key
+- FRIENDLI_TOKEN: Friendli AI API Token
+- HF_TOKEN (선택): 기본 HuggingFace 토큰
+"""
+
 import os
 import sys
+import json
+import argparse
+import subprocess
+import tempfile
+import textwrap
+import requests
+import shutil
 from pathlib import Path
+from typing import Optional, Dict, List
 
-# repo_to_space_auto 모듈 동적 임포트
-sys.path.insert(0, str(Path(__file__).parent))
-from repo_to_space_auto import deploy
+import gradio as gr
+import git
+from huggingface_hub import HfApi, login
 
-# OAuth 사용 가능 여부 확인
-OAUTH_ENABLED = os.getenv("OAUTH_CLIENT_ID") is not None
+# ========== Brave Search 헬퍼 ========== #
+def brave_search_repo(repo_url: str, count: int = 5) -> List[Dict]:
+    """Brave Search API로 레포지토리 메타데이터 수집"""
+    api_key = os.getenv("BAPI_TOKEN")
+    if not api_key:
+        raise RuntimeError("환경변수 BAPI_TOKEN이 설정되어 있지 않습니다.")
+    
+    headers = {"X-Subscription-Token": api_key, "Accept": "application/json"}
+    params = {"q": f'site:github.com "{repo_url}"', "count": count, "search_lang": "en"}
+    
+    try:
+        resp = requests.get(
+            "https://api.search.brave.com/res/v1/web/search",
+            headers=headers, 
+            params=params, 
+            timeout=10
+        )
+        resp.raise_for_status()
+        return resp.json().get("web", {}).get("results", [])
+    except Exception as e:
+        print(f"⚠️ Brave Search 경고: {e}")
+        return []
 
-def launch_deploy_oauth(repo_url, private, profile: gr.OAuthProfile | None):
-    """OAuth 인증 버전"""
-    if not profile:
-        return """### ❌ 로그인 필요
+# ========== Friendli LLM 헬퍼 ========== #
+def friendli_generate_scaffold(context: str) -> Dict:
+    """Friendli AI로 app.py 및 requirements.txt 자동 생성"""
+    token = os.getenv("FRIENDLI_TOKEN")
+    if not token:
+        raise RuntimeError("환경변수 FRIENDLI_TOKEN이 설정되어 있지 않습니다.")
+    
+    payload = {
+        "model": "meta-llama-3.1-70b-instruct",
+        "messages": [
+            {
+                "role": "system",
+                "content": textwrap.dedent("""
+                You are an expert Hugging Face Space architect. Given repository context, 
+                generate a Gradio app that showcases the repository's functionality.
+                
+                Output a JSON with these keys:
+                - app_py: Complete Gradio app code
+                - requirements_txt: Required Python packages
+                - need_docker: Boolean for Docker requirement
+                - dockerfile: Dockerfile content (if need_docker is true)
+                - summary: Brief description of the generated app
+                
+                Important guidelines:
+                1. Always use Gradio for the interface
+                2. Make the app functional and user-friendly
+                3. Include proper error handling
+                4. Add clear instructions in the interface
+                5. Use appropriate Gradio components for the task
+                """)
+            },
+            {"role": "user", "content": context}
+        ],
+        "max_tokens": 16384,
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "stream": False
+    }
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    try:
+        r = requests.post(
+            "https://api.friendli.ai/serverless/v1/chat/completions",
+            json=payload,
+            headers=headers,
+            timeout=120
+        )
+        r.raise_for_status()
+        
+        # JSON 응답 파싱
+        response_text = r.json()["choices"][0]["message"]["content"]
         
-상단의 'Sign in with Hugging Face' 버튼을 클릭해 로그인해주세요."""
+        # JSON 블록 추출 (```json ... ``` 형식 처리)
+        if "```json" in response_text:
+            start = response_text.find("```json") + 7
+            end = response_text.find("```", start)
+            response_text = response_text[start:end].strip()
+        
+        return json.loads(response_text)
+    except json.JSONDecodeError as e:
+        print(f"⚠️ JSON 파싱 오류: {e}")
+        # 기본 Gradio 앱 반환
+        return {
+            "app_py": textwrap.dedent("""
+                import gradio as gr
+                
+                def main():
+                    return "This is an auto-generated Gradio app. Please customize it based on your repository."
+                
+                demo = gr.Interface(
+                    fn=main,
+                    inputs=None,
+                    outputs="text",
+                    title="Auto-Generated Space",
+                    description="This Space was automatically created. Please update app.py to add your functionality."
+                )
+                
+                if __name__ == "__main__":
+                    demo.launch()
+            """),
+            "requirements_txt": "gradio>=4.0.0",
+            "need_docker": False,
+            "summary": "Basic Gradio template - please customize based on your repository"
+        }
+
+# ========== 메인 배포 로직 ========== #
+def deploy(repo_url: str, hf_token: str, private: bool = False, hardware: Optional[str] = None) -> str:
+    """레포지토리를 Gradio Space로 배포하고 Space URL 반환"""
+    # HF 로그인
+    login(hf_token)
+    api = HfApi(token=hf_token)
+    
+    # 사용자 정보 및 Space 이름 생성
+    user = api.whoami()["name"]
+    repo_name = Path(repo_url.rstrip("/")).name.lower()
+    repo_name = repo_name.replace(".", "-").replace("_", "-")
+    space_id = f"{user}/{repo_name}-space"
+    
+    print(f"📦 Space ID: {space_id}")
     
-    hf_token = profile.token
+    # Space 생성
+    api.create_repo(
+        repo_id=space_id,
+        repo_type="space",
+        space_sdk="gradio",
+        private=private,
+        exist_ok=True
+    )
     
-    # 토큰 정리 (OAuth에서도 안전하게)
-    if hf_token:
-        hf_token = hf_token.strip()
+    # Hardware 설정 (필요한 경우)
+    if hardware:
+        try:
+            api.request_space_hardware(repo_id=space_id, hardware=hardware)
+            print(f"🖥️ Hardware 설정: {hardware}")
+        except Exception as e:
+            print(f"⚠️ Hardware 설정 실패: {e}")
     
-    return _deploy_space(repo_url, hf_token, private)
+    with tempfile.TemporaryDirectory() as work_dir:
+        # 1) Brave Search로 메타데이터 수집
+        print("🔍 레포지토리 정보 수집 중...")
+        brave_meta = brave_search_repo(repo_url)
+        
+        # 2) 원본 레포지토리 클론
+        print("📥 레포지토리 클론 중...")
+        src_path = Path(work_dir) / "source"
+        git.Repo.clone_from(repo_url, src_path, depth=1)
+        
+        # README 읽기
+        readme_content = ""
+        readme_path = src_path / "README.md"
+        if readme_path.exists():
+            readme_content = readme_path.read_text(encoding="utf-8", errors="ignore")[:4000]
+        
+        # 디렉토리 구조 파악
+        tree_output = subprocess.run(
+            ["bash", "-c", f"find {src_path} -type f -name '*.py' -o -name '*.md' -o -name '*.txt' -o -name '*.json' -o -name '*.yaml' -o -name '*.yml' | head -n 50"],
+            capture_output=True,
+            text=True
+        ).stdout
+        
+        # 컨텍스트 생성
+        context = textwrap.dedent(f"""
+        ## Repository URL
+        {repo_url}
+        
+        ## Brave Search Metadata
+        {json.dumps(brave_meta, ensure_ascii=False, indent=2)}
+        
+        ## Repository Structure
+        {tree_output}
+        
+        ## README.md Content (first 4KB)
+        {readme_content}
+        
+        Please create a Gradio app that best showcases this repository's functionality.
+        If it's a model, create an inference interface. If it's a dataset, create a viewer.
+        If it's a library, create a demo. Make it user-friendly and functional.
+        """)
+        
+        # 3) Friendli AI로 스캐폴드 생성
+        print("🤖 AI로 Gradio 앱 생성 중...")
+        scaffold = friendli_generate_scaffold(context)
+        
+        # 4) Space 레포지토리 클론 및 파일 작성
+        print("📤 Space에 파일 업로드 중...")
+        dst_path = Path(work_dir) / "space"
+        
+        # HTTPS URL with token for authentication
+        space_url = f"https://{hf_token}@huggingface.co/spaces/{space_id}"
+        space_repo = git.Repo.clone_from(space_url, dst_path, depth=1)
+        
+        # 파일 작성
+        (dst_path / "app.py").write_text(scaffold["app_py"], encoding="utf-8")
+        (dst_path / "requirements.txt").write_text(scaffold["requirements_txt"], encoding="utf-8")
+        
+        if scaffold.get("need_docker"):
+            (dst_path / "Dockerfile").write_text(scaffold["dockerfile"], encoding="utf-8")
+        
+        # README.md 생성
+        readme_content = f"""---
+title: {repo_name.replace("-", " ").title()}
+emoji: 🚀
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.1
+app_file: app.py
+pinned: false
+---
 
-def launch_deploy_manual(repo_url, hf_token, private):
-    """수동 토큰 입력 버전"""
-    if not hf_token:
-        return """### ❌ 토큰 필요
+# {repo_name.replace("-", " ").title()}
+
+Automatically deployed from: {repo_url}
+
+## Summary
+{scaffold.get("summary", "Auto-generated Gradio Space")}
+
+---
+*Created by HF Space Auto-Deployer*
+"""
+        (dst_path / "README.md").write_text(readme_content, encoding="utf-8")
+        
+        # Git 커밋 및 푸시
+        space_repo.index.add(["app.py", "requirements.txt", "README.md"])
+        if scaffold.get("need_docker"):
+            space_repo.index.add(["Dockerfile"])
         
-Hugging Face Write 토큰을 입력해주세요."""
+        # Git 설정
+        space_repo.config_writer().set_value("user", "name", user).release()
+        space_repo.config_writer().set_value("user", "email", f"{user}@users.noreply.huggingface.co").release()
+        
+        space_repo.index.commit("Initial auto-deployment")
+        
+        # 푸시
+        origin = space_repo.remote("origin")
+        origin.push()
+    
+    return f"https://huggingface.co/spaces/{space_id}"
+
+# ========== Gradio UI ========== #
+def launch_deploy(repo_url: str, private: bool, request: gr.Request) -> str:
+    """Gradio UI에서 호출되는 배포 함수"""
+    # 토큰 가져오기 (우선순위: Gradio 인증 → 환경변수)
+    hf_token = None
     
-    # 토큰 정리 (공백, 줄바꿈 제거)
-    hf_token = hf_token.strip()
+    # Gradio 인증 헤더 확인
+    auth_header = request.headers.get("authorization")
+    if auth_header and auth_header.startswith("Bearer "):
+        hf_token = auth_header.split(" ")[1].strip()
     
-    # 토큰 형식 검증
-    if not hf_token.startswith("hf_"):
-        return """### ❌ 잘못된 토큰 형식
+    # 환경변수 폴백
+    if not hf_token:
+        hf_token = os.environ.get("HF_TOKEN")
+    
+    if not hf_token:
+        return """### ❌ 인증 필요
         
-토큰은 'hf_'로 시작해야 합니다.
-https://huggingface.co/settings/tokens 에서 Write 권한 토큰을 생성해주세요."""
+다음 중 하나의 방법으로 인증해주세요:
+1. **우측 상단 프로필 → Sign in with Hugging Face**
+2. **Space Settings → Variables and secrets → HF_TOKEN 설정**"""
     
-    return _deploy_space(repo_url, hf_token, private)
-
-def _deploy_space(repo_url, hf_token, private):
-    """공통 배포 로직"""
-    # URL 정리
+    # URL 검증
     repo_url = repo_url.strip()
+    if not repo_url:
+        return "### ❌ Repository URL을 입력해주세요."
     
-    # URL 검증
-    if not repo_url.startswith(("https://github.com/", "http://github.com/", "[email protected]:")):
-        return """### ❌ 잘못된 Repository URL
+    if not any(repo_url.startswith(prefix) for prefix in ["https://github.com/", "http://github.com/"]):
+        return """### ❌ 잘못된 URL 형식
         
-GitHub URL 형식이 올바르지 않습니다.
-예시: https://github.com/username/repository"""
+GitHub URL을 입력해주세요.
+예: https://github.com/username/repository"""
     
-    # 환경변수 대신 직접 토큰 전달
+    # 배포 실행
     try:
-        link = deploy(repo_url, hf_token, private=private)
-        return f"""### ✅ Space 생성 완료
+        space_url = deploy(repo_url, hf_token, private)
+        return f"""### ✅ Space 배포 완료!
 
 🎉 성공적으로 배포되었습니다!
 
-**Space URL:** [{link}]({link})
+**Space URL**: [{space_url}]({space_url})
+
+**다음 단계:**
+1. Space 페이지 방문
+2. 빌드 로그 확인 (우측 상단 "Logs" 탭)
+3. 빌드 완료 대기 (보통 2-5분)
+4. 필요시 app.py 수정
 
 ---
-*배포된 Space가 제대로 작동하는지 확인해보세요.*"""
+💡 **팁**: Space가 제대로 작동하지 않으면 Files 탭에서 app.py를 직접 수정할 수 있습니다."""
+    
     except Exception as e:
         error_msg = str(e)
         
-        # 특정 오류에 대한 상세 안내
+        # 상세한 오류 안내
         if "BAPI_TOKEN" in error_msg:
             return """### ❌ Brave Search API 토큰 필요
 
-Space Settings > Variables and secrets에서 `BAPI_TOKEN`을 설정해주세요.
-[Brave Search API](https://brave.com/search/api/) 에서 무료 키를 발급받을 수 있습니다."""
+**설정 방법:**
+1. [Brave Search API](https://brave.com/search/api/) 가입
+2. 무료 API Key 발급
+3. **이 Space의** Settings → Variables and secrets
+4. `BAPI_TOKEN` = `[발급받은 키]` 추가"""
+        
         elif "FRIENDLI_TOKEN" in error_msg:
             return """### ❌ Friendli AI 토큰 필요
 
-Space Settings > Variables and secrets에서 `FRIENDLI_TOKEN`을 설정해주세요.
-[Friendli AI](https://friendli.ai/) 에서 API 키를 발급받을 수 있습니다."""
-        elif "Invalid header value" in error_msg:
-            return """### ❌ 토큰 오류
-
-토큰에 잘못된 문자가 포함되어 있습니다.
-토큰을 다시 복사하여 공백이나 줄바꿈 없이 붙여넣어주세요."""
-        elif "401" in error_msg or "403" in error_msg:
+**설정 방법:**
+1. [Friendli AI](https://friendli.ai/) 가입
+2. API Key 발급
+3. **이 Space의** Settings → Variables and secrets
+4. `FRIENDLI_TOKEN` = `[발급받은 키]` 추가"""
+        
+        elif "401" in error_msg or "403" in error_msg or "Unauthorized" in error_msg:
             return """### ❌ 인증 실패
 
-토큰이 유효하지 않거나 Write 권한이 없습니다.
-https://huggingface.co/settings/tokens 에서 Write 권한이 있는 토큰인지 확인해주세요."""
+**해결 방법:**
+1. [토큰 페이지](https://huggingface.co/settings/tokens) 방문
+2. "New token" 클릭
+3. **Write** 권한 체크 ✅
+4. Space Settings에서 HF_TOKEN 업데이트"""
+        
         else:
             return f"""### ❌ 배포 오류
 
-오류 내용: `{error_msg}`
+**오류 내용:**
+```
+{error_msg}
+```
 
-**가능한 원인:**
-- 잘못된 Repository URL
-- 권한 부족 (write 권한 필요)
-- 네트워크 문제"""
+**일반적인 해결 방법:**
+1. Repository가 public인지 확인
+2. URL 형식 확인 (https://github.com/user/repo)
+3. 네트워크 연결 확인
+4. 잠시 후 재시도"""
 
-# Gradio 앱 구성
-with gr.Blocks(
-    title="HF Space Auto-Deployer",
-    theme=gr.themes.Soft(),
-    css="""
-    .main-container { max-width: 800px; margin: 0 auto; }
-    .gr-button-primary { background-color: #2563eb !important; }
-    .status-box { padding: 20px; border-radius: 8px; margin-top: 20px; }
-    """
-) as demo:
-    gr.Markdown("""
-    # 🚀 Git Repository → Hugging Face Space 자동 배포
-    
-    공개 Git 저장소를 Hugging Face Gradio Space로 자동 변환하고 배포합니다.
-    
-    ## 사용 방법
-    1. **인증**: OAuth 로그인 또는 토큰 입력
-    2. **Repository URL 입력**
-    3. **Deploy 버튼 클릭**
-    
-    ---
-    """)
-    
-    with gr.Column(elem_classes="main-container"):
-        if OAUTH_ENABLED:
-            # OAuth 버전
-            gr.LoginButton(
-                value="Sign in with Hugging Face 🤗",
-                variant="primary",
-                size="lg"
-            )
-            
-            gr.Markdown("### 📝 배포 설정")
-            
-            repo_input = gr.Textbox(
-                label="Git Repository URL",
-                placeholder="https://github.com/username/repository",
-                info="공개 저장소 URL을 입력하세요"
-            )
-            
-            private_checkbox = gr.Checkbox(
-                label="🔒 Private Space로 생성",
-                value=False,
-                info="체크하면 비공개 Space로 생성됩니다"
-            )
-            
-            deploy_btn = gr.Button(
-                "🚀 Deploy to Space",
-                variant="primary",
-                size="lg"
-            )
-            
-            output_status = gr.Markdown(
-                elem_classes="status-box",
-                visible=False
-            )
+# ========== Gradio App ========== #
+def create_ui():
+    """Gradio UI 생성"""
+    with gr.Blocks(
+        title="HF Space Auto-Deployer",
+        theme=gr.themes.Soft(),
+        css="""
+        .main-container { 
+            max-width: 800px; 
+            margin: 0 auto; 
+            padding: 20px;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 30px;
+            padding: 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border-radius: 10px;
+        }
+        .header h1 {
+            margin: 0;
+            font-size: 2.5em;
+        }
+        .header p {
+            margin: 10px 0 0 0;
+            opacity: 0.9;
+        }
+        .gr-button-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+            border: none !important;
+            font-size: 1.1em !important;
+            padding: 12px 30px !important;
+        }
+        .gr-button-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+        }
+        .status-box {
+            padding: 20px;
+            border-radius: 10px;
+            margin-top: 20px;
+            border: 1px solid #e0e0e0;
+            background-color: #f9f9f9;
+        }
+        .info-box {
+            background-color: #e3f2fd;
+            padding: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #2196F3;
+            margin: 10px 0;
+        }
+        .examples-box {
+            background-color: #f3e5f5;
+            padding: 15px;
+            border-radius: 8px;
+            margin: 10px 0;
+        }
+        """
+    ) as demo:
+        with gr.Column(elem_classes="main-container"):
+            # 헤더
+            gr.HTML("""
+            <div class="header">
+                <h1>🚀 GitHub → HuggingFace Space</h1>
+                <p>AI가 당신의 GitHub 프로젝트를 Gradio 앱으로 변환합니다</p>
+            </div>
+            """)
             
-            # OAuth 이벤트 핸들러
-            deploy_btn.click(
-                fn=launch_deploy_oauth,
-                inputs=[repo_input, private_checkbox],
-                outputs=output_status
-            ).then(
-                fn=lambda: gr.update(visible=True),
-                outputs=output_status
-            )
-        else:
-            # 수동 토큰 입력 버전
+            # 인증 안내
             gr.Markdown("""
-            ### 🔐 인증 정보
-            
-            > **참고**: OAuth가 설정되지 않은 Space입니다. 
-            > Space 설정에서 `hf_oauth: true`를 추가하면 자동 로그인을 사용할 수 있습니다.
+            <div class="info-box">
+            <b>🔐 인증 방법:</b><br>
+            • <b>방법 1</b>: 우측 상단 프로필 → Sign in with Hugging Face<br>
+            • <b>방법 2</b>: Space Settings에서 HF_TOKEN 환경변수 설정
+            </div>
             """)
             
-            token_input = gr.Textbox(
-                label="Hugging Face Write Token",
-                type="password",
-                placeholder="hf_xxxxxxxxxxxxxxxxxxxxx",
-                info="https://huggingface.co/settings/tokens 에서 Write 권한 토큰 생성"
-            )
-            
-            gr.Markdown("### 📝 배포 설정")
-            
-            repo_input = gr.Textbox(
-                label="Git Repository URL",
-                placeholder="https://github.com/username/repository",
-                info="공개 저장소 URL을 입력하세요"
-            )
-            
-            private_checkbox = gr.Checkbox(
-                label="🔒 Private Space로 생성",
-                value=False,
-                info="체크하면 비공개 Space로 생성됩니다"
-            )
+            # 입력 필드
+            with gr.Group():
+                repo_input = gr.Textbox(
+                    label="📦 GitHub Repository URL",
+                    placeholder="https://github.com/username/repository",
+                    info="Public repository URL을 입력하세요",
+                    lines=1
+                )
+                
+                private_checkbox = gr.Checkbox(
+                    label="🔒 Private Space로 생성",
+                    value=False,
+                    info="체크하면 본인만 접근 가능한 Space가 생성됩니다"
+                )
             
+            # 배포 버튼
             deploy_btn = gr.Button(
-                "🚀 Deploy to Space",
+                "🚀 Space 생성하기",
                 variant="primary",
                 size="lg"
             )
             
+            # 상태 출력
             output_status = gr.Markdown(
                 elem_classes="status-box",
                 visible=False
             )
             
-            # 수동 입력 이벤트 핸들러
-            deploy_btn.click(
-                fn=launch_deploy_manual,
-                inputs=[repo_input, token_input, private_checkbox],
-                outputs=output_status
-            ).then(
-                fn=lambda: gr.update(visible=True),
-                outputs=output_status
-            )
-        
-        # 공통 예시 및 도움말
-        gr.Markdown("""
-        ### 💡 예시
-        - `https://github.com/gradio-app/gradio`
-        - `https://github.com/huggingface/transformers`
+            # 예시
+            gr.HTML("""
+            <div class="examples-box">
+                <b>💡 예시 프로젝트:</b><br>
+                • <code>https://github.com/gradio-app/gradio/tree/main/demo/hello_world</code><br>
+                • <code>https://github.com/huggingface/transformers</code><br>
+                • <code>https://github.com/CompVis/stable-diffusion</code>
+            </div>
+            """)
+            
+            # 사용 가이드
+            with gr.Accordion("📚 사용 가이드", open=False):
+                gr.Markdown("""
+                ### 작동 원리
+                1. **🔍 분석**: Brave Search로 레포지토리 정보 수집
+                2. **🤖 생성**: Friendli AI가 맞춤형 Gradio 앱 코드 생성
+                3. **📤 배포**: HuggingFace Space에 자동 업로드 및 빌드
+                
+                ### 지원하는 프로젝트 유형
+                - ✅ **ML 모델**: 추론 인터페이스 자동 생성
+                - ✅ **데이터셋**: 데이터 탐색기 생성
+                - ✅ **라이브러리**: 데모 앱 생성
+                - ✅ **일반 프로젝트**: 기능 쇼케이스 생성
+                
+                ### 필요한 API 키
+                1. **BAPI_TOKEN**: [Brave Search API](https://brave.com/search/api/) (무료)
+                2. **FRIENDLI_TOKEN**: [Friendli AI](https://friendli.ai/) (무료 크레딧 제공)
+                
+                ### 문제 해결
+                - **빌드 실패**: Space의 Logs 탭 확인
+                - **앱 수정**: Files 탭에서 app.py 직접 편집
+                - **GPU 필요**: Space Settings에서 Hardware 변경
+                """)
         
-        ### ⚠️ 주의사항
-        - **환경변수 필요**: `BAPI_TOKEN` (Brave Search API), `FRIENDLI_TOKEN` (Friendli AI)
-        - Space 이름은 repository 이름을 기반으로 자동 생성됩니다
-        - GPU가 필요한 경우 Space 생성 후 수동 설정이 필요합니다
-        """)
+        # 이벤트 핸들러
+        deploy_btn.click(
+            fn=launch_deploy,
+            inputs=[repo_input, private_checkbox],
+            outputs=output_status
+        ).then(
+            fn=lambda: gr.update(visible=True),
+            outputs=output_status
+        )
+    
+    return demo
 
-if __name__ == "__main__":
-    # 시작 시 환경 체크
-    print("\n" + "="*50)
-    print("🚀 HF Space Auto-Deployer 시작")
-    print("="*50)
+# ========== CLI 지원 ========== #
+def main():
+    """CLI 실행을 위한 메인 함수"""
+    parser = argparse.ArgumentParser(description="Git 레포를 Hugging Face Space로 자동 배포")
+    parser.add_argument("--repo_url", help="GitHub repository URL")
+    parser.add_argument("--hf_token", help="HuggingFace write token")
+    parser.add_argument("--private", action="store_true", help="Create private Space")
+    parser.add_argument("--hardware", help="GPU tier (e.g., 't4-medium')")
+    parser.add_argument("--no-ui", action="store_true", help="Run without Gradio UI")
     
-    # 필수 환경변수 체크
-    missing_vars = []
-    if not os.getenv("BAPI_TOKEN"):
-        missing_vars.append("BAPI_TOKEN (Brave Search API)")
-    if not os.getenv("FRIENDLI_TOKEN"):
-        missing_vars.append("FRIENDLI_TOKEN (Friendli AI)")
+    args = parser.parse_args()
     
-    if missing_vars:
-        print("\n⚠️  다음 환경변수가 설정되지 않았습니다:")
-        for var in missing_vars:
-            print(f"   - {var}")
-        print("\nSpace Settings > Variables and secrets에서 설정해주세요.")
+    # CLI 모드
+    if args.no_ui and args.repo_url and args.hf_token:
+        try:
+            url = deploy(args.repo_url, args.hf_token, args.private, args.hardware)
+            print(f"✅ 배포 성공: {url}")
+        except Exception as e:
+            print(f"❌ 배포 실패: {e}", file=sys.stderr)
+            sys.exit(1)
+    # Gradio UI 모드
     else:
-        print("✅ 모든 필수 환경변수가 설정되었습니다.")
-    
-    # OAuth 상태 확인
-    if OAUTH_ENABLED:
-        print("✅ OAuth가 활성화되었습니다.")
-    else:
-        print("ℹ️  OAuth가 비활성화되었습니다. (수동 토큰 입력 모드)")
-    
-    print("="*50 + "\n")
-    
-    demo.launch(
-        ssr_mode=False,  # SSR 비활성화로 경고 제거
-        show_error=True,
-        quiet=True  # Gradio 기본 출력 최소화
-    )
+        # 환경 상태 출력
+        print("\n" + "="*60)
+        print("🚀 HF Space Auto-Deployer")
+        print("="*60)
+        
+        # 환경변수 체크
+        env_checks = []
+        env_checks.append("✅ HF_TOKEN" if os.getenv("HF_TOKEN") else "⚠️  HF_TOKEN (선택사항)")
+        env_checks.append("✅ BAPI_TOKEN" if os.getenv("BAPI_TOKEN") else "❌ BAPI_TOKEN (필수)")
+        env_checks.append("✅ FRIENDLI_TOKEN" if os.getenv("FRIENDLI_TOKEN") else "❌ FRIENDLI_TOKEN (필수)")
+        
+        print("환경변수 상태:")
+        for check in env_checks:
+            print(f"  {check}")
+        
+        print("="*60 + "\n")
+        
+        # Gradio 앱 실행
+        demo = create_ui()
+        demo.launch(
+            share=False,
+            server_name="0.0.0.0",
+            server_port=7860
+        )
+
+if __name__ == "__main__":
+    main()