Implement custom Gradio State-based login system

- Remove Gradio's built-in HTTP auth
- Add login/logout pages with session management
- Implement handle_login() and handle_logout() functions
- Use gr.State for session persistence
- Login page visible by default, main page hidden
- Logout button in main page header

Note: Page refresh will log out user (State limitation)

app.py

@@ -473,153 +473,203 @@ def create_app():
 
     with gr.Blocks(title="PixelFree v3.0.0", theme=gr.themes.Soft(), css=custom_css) as demo:
 
-        # 메인 헤더
-        gr.Markdown("# 🎨 PixelFree Studio")
-
-        # 입력 섹션
-        gr.Markdown("## 📸 입력 이미지")
-
-        input_state = gr.State(None)
-        bg_removed_state = gr.State(None)
-        selected_bg_state = gr.State(None)
-        selected_face_state = gr.State(None)
-        last_output_state = gr.State(None)
-
-        input_image = gr.Image(label="입력 이미지", type="pil", height=540)
-
-        # 결과 섹션
-        gr.Markdown("## ✨ 결과 이미지")
-        output_image = gr.Image(label="처리된 이미지", type="pil", height=500, interactive=False)
-        download_btn = gr.DownloadButton(
-            "📥 사진 다운로드",
-            value=None,
-            interactive=False
-        )
-
-        # 비디오 생성 섹션
-        gr.Markdown("## 🎬 AI 비디오 생성")
-        with gr.Row():
-            video_output = gr.Video(
-                label="생성된 영상",
-                height=360,
-                interactive=False,
-                autoplay=True,
+        # 세션 상태 관리
+        session_user = gr.State(None)
+
+        # 로그인 페이지
+        with gr.Column(visible=True, elem_id="login-page") as login_page:
+            gr.Markdown("# 🔐 PixelFree 로그인")
+            gr.Markdown("허가된 사용자만 접근 가능합니다.")
+            username_input = gr.Textbox(
+                label="사용자명",
+                placeholder="username을 입력하세요",
+                max_lines=1
             )
-            with gr.Column():
-                gr.Markdown("최근 이미지 결과를 기반으로 짧은 클립을 생성합니다.")
-                generate_video_btn = gr.Button(
-                    "🎬 영상 생성하기",
-                    variant="primary",
-                    size="lg",
-                    interactive=False,
-                )
-
-        # 배경 제거 섹션
-        gr.Markdown("## 🎯 AI 배경 제거")
-        remove_bg_btn = gr.Button("🚀 배경 제거 실행", variant="primary", size="lg", interactive=False)
-
-        # AI 생성 기능 섹션
-        gr.Markdown("## 🎨 AI 생성 기능")
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### 🏞️ 배경 생성")
-                with gr.Tabs():
-                    with gr.Tab("🏠 실내"):
-                        indoor_gallery = gr.Gallery(
-                            value=bg_images["indoor"],
-                            columns=4,
-                            show_label=False, interactive=False,
-                            allow_preview=False,
-                            object_fit="contain"
-                        )
-                    with gr.Tab("🌳 아웃도어"):
-                        outdoor_gallery = gr.Gallery(
-                            value=bg_images["outdoor"],
-                            columns=4,
-                            rows=4, show_label=False, interactive=False,
-                            allow_preview=False,
-                            object_fit="contain"
-                        )
-                hq_checkbox = gr.Checkbox(label="✨ 고품질 모드", value=False)
-                generate_bg_btn = gr.Button("🎨 배경 생성하기", variant="secondary", interactive=False, size="lg")
-            with gr.Column():
-                gr.Markdown("### 👤 얼굴 교체")
-                with gr.Tabs():
-                    with gr.Tab("👨 남성"):
-                        man_gallery = gr.Gallery(
-                            value=face_images["man_pil"],
-                            columns=4,
-                            rows=2, show_label=False, interactive=False,
-                            allow_preview=False,
-                            object_fit="contain"
-                        )
-                    with gr.Tab("👩 여성"):
-                        woman_gallery = gr.Gallery(
-                            value=face_images["woman_pil"],
-                            columns=4,
-                            rows=2, show_label=False, interactive=False,
-                            allow_preview=False,
-                            object_fit="contain"
-                        )
-                swap_face_btn = gr.Button("🔄 얼굴 교체 적용", variant="secondary", interactive=False, size="lg")
-        # Collapsible history section with image grid
-        with gr.Accordion("📜 작업 히스토리", open=False):
-            # History gallery with preview enabled
-            history_gallery = gr.Gallery(
-                value=[img for img, _ in get_history_items(20)],
-                label=None,
-                show_label=False,
-                columns=5,
-                rows=4,
-                height=500,
-                object_fit="contain",
-                allow_preview=True,
-                elem_id="history-gallery",
-                interactive=False
+            password_input = gr.Textbox(
+                label="비밀번호",
+                placeholder="password를 입력하세요",
+                type="password",
+                max_lines=1
             )
-
-        def make_download_update(image: Optional[Image.Image], prefix: str = "pixelfree_output"):
-            if image is None:
-                return gr.update(value=None, interactive=False)
-            filename = f"{prefix}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
-            temp_path = f"/tmp/{filename}"
-            image.save(temp_path, "PNG")
-            return gr.update(value=temp_path, interactive=True)
-
-        def history_update():
-            """Update history gallery with original images."""
-            items = get_history_items(20)
-            images = [img for img, _ in items]
-            return gr.update(value=images)
-
-        def disable_all_buttons():
-            disabled = gr.update(interactive=False)
-            return disabled, disabled, disabled, disabled
-
-        def compute_button_states(
-            input_img: Optional[Image.Image],
-            last_output: Optional[Image.Image],
-            bg_removed: Optional[Image.Image],
-            selected_bg: Optional[Image.Image],
-            selected_face: Optional[Image.Image],
-        ):
-            remove_ready = gr.update(interactive=input_img is not None)
-            video_ready = gr.update(interactive=input_img is not None)
-            bg_ready = gr.update(interactive=(bg_removed is not None and selected_bg is not None))
-            swap_ready = gr.update(
-                interactive=(selected_face is not None and ((last_output is not None) or (input_img is not None)))
+            login_btn = gr.Button("🔓 로그인", variant="primary", size="lg")
+            login_msg = gr.Markdown("")
+
+        # 메인 페이지 (초기에는 숨김)
+        with gr.Column(visible=False, elem_id="main-page") as main_page:
+
+            # 메인 헤더
+            with gr.Row():
+                gr.Markdown("# 🎨 PixelFree Studio")
+                logout_btn = gr.Button("🚪 로그아웃", variant="secondary", size="sm")
+
+            # 입력 섹션
+            gr.Markdown("## 📸 입력 이미지")
+
+            input_state = gr.State(None)
+            bg_removed_state = gr.State(None)
+            selected_bg_state = gr.State(None)
+            selected_face_state = gr.State(None)
+            last_output_state = gr.State(None)
+
+            input_image = gr.Image(label="입력 이미지", type="pil", height=540)
+
+            # 결과 섹션
+            gr.Markdown("## ✨ 결과 이미지")
+            output_image = gr.Image(label="처리된 이미지", type="pil", height=500, interactive=False)
+            download_btn = gr.DownloadButton(
+                "📥 사진 다운로드",
+                value=None,
+                interactive=False
             )
-            return remove_ready, video_ready, bg_ready, swap_ready
 
+            # 비디오 생성 섹션
+            gr.Markdown("## 🎬 AI 비디오 생성")
+            with gr.Row():
+                video_output = gr.Video(
+                    label="생성된 영상",
+                    height=360,
+                    interactive=False,
+                    autoplay=True,
+                )
+                with gr.Column():
+                    gr.Markdown("최근 이미지 결과를 기반으로 짧은 클립을 생성합니다.")
+                    generate_video_btn = gr.Button(
+                        "🎬 영상 생성하기",
+                        variant="primary",
+                        size="lg",
+                        interactive=False,
+                    )
+
+            # 배경 제거 섹션
+            gr.Markdown("## 🎯 AI 배경 제거")
+            remove_bg_btn = gr.Button("🚀 배경 제거 실행", variant="primary", size="lg", interactive=False)
+
+            # AI 생성 기능 섹션
+            gr.Markdown("## 🎨 AI 생성 기능")
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🏞️ 배경 생성")
+                    with gr.Tabs():
+                        with gr.Tab("🏠 실내"):
+                            indoor_gallery = gr.Gallery(
+                                value=bg_images["indoor"],
+                                columns=4,
+                                show_label=False, interactive=False,
+                                allow_preview=False,
+                                object_fit="contain"
+                            )
+                        with gr.Tab("🌳 아웃도어"):
+                            outdoor_gallery = gr.Gallery(
+                                value=bg_images["outdoor"],
+                                columns=4,
+                                rows=4, show_label=False, interactive=False,
+                                allow_preview=False,
+                                object_fit="contain"
+                            )
+                    hq_checkbox = gr.Checkbox(label="✨ 고품질 모드", value=False)
+                    generate_bg_btn = gr.Button("🎨 배경 생성하기", variant="secondary", interactive=False, size="lg")
+                with gr.Column():
+                    gr.Markdown("### 👤 얼굴 교체")
+                    with gr.Tabs():
+                        with gr.Tab("👨 남성"):
+                            man_gallery = gr.Gallery(
+                                value=face_images["man_pil"],
+                                columns=4,
+                                rows=2, show_label=False, interactive=False,
+                                allow_preview=False,
+                                object_fit="contain"
+                            )
+                        with gr.Tab("👩 여성"):
+                            woman_gallery = gr.Gallery(
+                                value=face_images["woman_pil"],
+                                columns=4,
+                                rows=2, show_label=False, interactive=False,
+                                allow_preview=False,
+                                object_fit="contain"
+                            )
+                    swap_face_btn = gr.Button("🔄 얼굴 교체 적용", variant="secondary", interactive=False, size="lg")
+            # Collapsible history section with image grid
+            with gr.Accordion("📜 작업 히스토리", open=False):
+                # History gallery with preview enabled
+                history_gallery = gr.Gallery(
+                    value=[img for img, _ in get_history_items(20)],
+                    label=None,
+                    show_label=False,
+                    columns=5,
+                    rows=4,
+                    height=500,
+                    object_fit="contain",
+                    allow_preview=True,
+                    elem_id="history-gallery",
+                    interactive=False
+                )
 
-        def on_upload(new_image: Optional[Image.Image]):
-            if new_image is None:
-                gr.Warning("입력 이미지를 업로드해주세요.")
-                remove_ready, video_ready, bg_ready, swap_ready = disable_all_buttons()
-                return (
+            def make_download_update(image: Optional[Image.Image], prefix: str = "pixelfree_output"):
+                if image is None:
+                    return gr.update(value=None, interactive=False)
+                filename = f"{prefix}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png"
+                temp_path = f"/tmp/{filename}"
+                image.save(temp_path, "PNG")
+                return gr.update(value=temp_path, interactive=True)
+
+            def history_update():
+                """Update history gallery with original images."""
+                items = get_history_items(20)
+                images = [img for img, _ in items]
+                return gr.update(value=images)
+
+            def disable_all_buttons():
+                disabled = gr.update(interactive=False)
+                return disabled, disabled, disabled, disabled
+
+            def compute_button_states(
+                input_img: Optional[Image.Image],
+                last_output: Optional[Image.Image],
+                bg_removed: Optional[Image.Image],
+                selected_bg: Optional[Image.Image],
+                selected_face: Optional[Image.Image],
+            ):
+                remove_ready = gr.update(interactive=input_img is not None)
+                video_ready = gr.update(interactive=input_img is not None)
+                bg_ready = gr.update(interactive=(bg_removed is not None and selected_bg is not None))
+                swap_ready = gr.update(
+                    interactive=(selected_face is not None and ((last_output is not None) or (input_img is not None)))
+                )
+                return remove_ready, video_ready, bg_ready, swap_ready
+
+
+            def on_upload(new_image: Optional[Image.Image]):
+                if new_image is None:
+                    gr.Warning("입력 이미지를 업로드해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = disable_all_buttons()
+                    return (
+                        None,
+                        None,
+                        None,
+                        None,
+                        None,
+                        gr.update(value=None),
+                        make_download_update(None),
+                        gr.update(value=None),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                        history_update(),
+                    )
+
+                gr.Info("입력 이미지를 불러왔습니다.")
+                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                    new_image,
+                    None,
                     None,
                     None,
                     None,
+                )
+                return (
+                    new_image,
+                    None,
+                    None,
                     None,
                     None,
                     gr.update(value=None),
@@ -632,156 +682,151 @@ def create_app():
                     history_update(),
                 )
 
-            gr.Info("입력 이미지를 불러왔습니다.")
-            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                new_image,
-                None,
-                None,
-                None,
-                None,
-            )
-            return (
-                new_image,
-                None,
-                None,
-                None,
-                None,
-                gr.update(value=None),
-                make_download_update(None),
-                gr.update(value=None),
-                remove_ready,
-                video_ready,
-                bg_ready,
-                swap_ready,
-                history_update(),
-            )
-
-        def handle_remove_background(
-            input_img: Optional[Image.Image],
-            current_bg_removed: Optional[Image.Image],
-            selected_bg: Optional[Image.Image],
-            current_output: Optional[Image.Image],
-            selected_face: Optional[Image.Image],
-        ):
-            if input_img is None:
-                gr.Warning("입력 이미지를 먼저 업로드해주세요.")
-                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                    input_img,
-                    current_output,
-                    current_bg_removed,
-                    selected_bg,
-                    selected_face,
-                )
+            def handle_remove_background(
+                input_img: Optional[Image.Image],
+                current_bg_removed: Optional[Image.Image],
+                selected_bg: Optional[Image.Image],
+                current_output: Optional[Image.Image],
+                selected_face: Optional[Image.Image],
+            ):
+                if input_img is None:
+                    gr.Warning("입력 이미지를 먼저 업로드해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        current_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        current_bg_removed,
+                        current_output,
+                        gr.update(),
+                        make_download_update(current_output),
+                        bg_ready,
+                        swap_ready,
+                        remove_ready,
+                        video_ready,
+                        history_update(),
+                    )
+                    return
+
+                remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
                 yield (
                     current_bg_removed,
                     current_output,
                     gr.update(),
                     make_download_update(current_output),
-                    bg_ready,
-                    swap_ready,
-                    remove_ready,
-                    video_ready,
+                    bg_disabled,
+                    swap_disabled,
+                    remove_disabled,
+                    video_disabled,
                     history_update(),
                 )
-                return
-
-            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
-            yield (
-                current_bg_removed,
-                current_output,
-                gr.update(),
-                make_download_update(current_output),
-                bg_disabled,
-                swap_disabled,
-                remove_disabled,
-                video_disabled,
-                history_update(),
-            )
 
-            removed, message = processor.remove_background(input_img)
-            if removed is None:
-                gr.Warning(message)
+                removed, message = processor.remove_background(input_img)
+                if removed is None:
+                    gr.Warning(message)
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        current_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        current_bg_removed,
+                        current_output,
+                        gr.update(value=current_output),
+                        make_download_update(current_output),
+                        bg_ready,
+                        swap_ready,
+                        remove_ready,
+                        video_ready,
+                        history_update(),
+                    )
+                    return
+
+                gr.Info(message)
+                add_to_history(removed, "bg_remove")
                 remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
                     input_img,
-                    current_output,
-                    current_bg_removed,
+                    removed,
+                    removed,
                     selected_bg,
                     selected_face,
                 )
                 yield (
-                    current_bg_removed,
-                    current_output,
-                    gr.update(value=current_output),
-                    make_download_update(current_output),
+                    removed,
+                    removed,
+                    gr.update(value=removed),
+                    make_download_update(removed, "background_removed"),
                     bg_ready,
                     swap_ready,
                     remove_ready,
                     video_ready,
                     history_update(),
                 )
-                return
-
-            gr.Info(message)
-            add_to_history(removed, "bg_remove")
-            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                input_img,
-                removed,
-                removed,
-                selected_bg,
-                selected_face,
-            )
-            yield (
-                removed,
-                removed,
-                gr.update(value=removed),
-                make_download_update(removed, "background_removed"),
-                bg_ready,
-                swap_ready,
-                remove_ready,
-                video_ready,
-                history_update(),
-            )
 
-        def on_generate_video(
-            last_output: Optional[Image.Image],
-            input_img: Optional[Image.Image],
-            current_bg_removed: Optional[Image.Image],
-            selected_bg: Optional[Image.Image],
-            selected_face: Optional[Image.Image],
-        ):
-            base_image = last_output or input_img
-            if base_image is None:
-                gr.Warning("입력 이미지를 먼저 업로드해주세요.")
-                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                    input_img,
-                    last_output,
-                    current_bg_removed,
-                    selected_bg,
-                    selected_face,
-                )
+            def on_generate_video(
+                last_output: Optional[Image.Image],
+                input_img: Optional[Image.Image],
+                current_bg_removed: Optional[Image.Image],
+                selected_bg: Optional[Image.Image],
+                selected_face: Optional[Image.Image],
+            ):
+                base_image = last_output or input_img
+                if base_image is None:
+                    gr.Warning("입력 이미지를 먼저 업로드해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        gr.update(value=None),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
                 yield (
-                    gr.update(value=None),
+                    gr.update(),
                     history_update(),
-                    remove_ready,
-                    video_ready,
-                    bg_ready,
-                    swap_ready,
+                    remove_disabled,
+                    video_disabled,
+                    bg_disabled,
+                    swap_disabled,
                 )
-                return
-
-            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
-            yield (
-                gr.update(),
-                history_update(),
-                remove_disabled,
-                video_disabled,
-                bg_disabled,
-                swap_disabled,
-            )
 
-            video_path, message = processor.generate_video(base_image)
-            if video_path is None:
-                gr.Warning(message)
+                video_path, message = processor.generate_video(base_image)
+                if video_path is None:
+                    gr.Warning(message)
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        gr.update(value=None),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                gr.Info(message)
+                add_to_history(base_image, "video")
                 remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
                     input_img,
                     last_output,
@@ -790,419 +835,438 @@ def create_app():
                     selected_face,
                 )
                 yield (
-                    gr.update(value=None),
+                    gr.update(value=video_path),
                     history_update(),
                     remove_ready,
                     video_ready,
                     bg_ready,
                     swap_ready,
                 )
-                return
-
-            gr.Info(message)
-            add_to_history(base_image, "video")
-            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                input_img,
-                last_output,
-                current_bg_removed,
-                selected_bg,
-                selected_face,
-            )
-            yield (
-                gr.update(value=video_path),
-                history_update(),
-                remove_ready,
-                video_ready,
-                bg_ready,
-                swap_ready,
-            )
 
-        def load_background_image(category: str, index: int) -> Optional[Image.Image]:
-            key = f"{category}_pil"
-            paths = bg_images.get(key, [])
-            if 0 <= index < len(paths):
-                path = paths[index]
-                return load_full_image(path)
-            return None
-
-        def on_select_background(
-            evt: gr.SelectData,
-            category: str,
-            bg_removed: Optional[Image.Image],
-        ):
-            index = getattr(evt, "index", None)
-            if index is None:
-                gr.Warning("선택 정보를 확인할 수 없습니다.")
-                return None, gr.update(interactive=False)
-            image = load_background_image(category, index)
-            if image is None:
-                gr.Warning("선택한 배경 이미지를 불러오지 못했습니다.")
-                return None, gr.update(interactive=False)
-            gr.Info("배경 이미지를 선택했습니다.")
-            ready = gr.update(interactive=bg_removed is not None)
-            return image, ready
-
-        def on_generate_background(
-            last_output: Optional[Image.Image],
-            selected_bg: Optional[Image.Image],
-            hq_mode: bool,
-            input_img: Optional[Image.Image],
-            current_bg_removed: Optional[Image.Image],
-            selected_face: Optional[Image.Image],
-        ):
-            if last_output is None:
-                gr.Warning("먼저 배경 제거를 실행해주세요.")
-                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                    input_img,
-                    last_output,
-                    current_bg_removed,
-                    selected_bg,
-                    selected_face,
-                )
-                yield (
-                    last_output,
-                    gr.update(value=last_output),
-                    make_download_update(last_output),
-                    history_update(),
-                    remove_ready,
-                    video_ready,
-                    bg_ready,
-                    swap_ready,
-                )
-                return
+            def load_background_image(category: str, index: int) -> Optional[Image.Image]:
+                key = f"{category}_pil"
+                paths = bg_images.get(key, [])
+                if 0 <= index < len(paths):
+                    path = paths[index]
+                    return load_full_image(path)
+                return None
 
-            if selected_bg is None:
-                gr.Warning("사용할 배경 이미지를 선택해주세요.")
-                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                    input_img,
-                    last_output,
-                    current_bg_removed,
-                    selected_bg,
-                    selected_face,
-                )
+            def on_select_background(
+                evt: gr.SelectData,
+                category: str,
+                bg_removed: Optional[Image.Image],
+            ):
+                index = getattr(evt, "index", None)
+                if index is None:
+                    gr.Warning("선택 정보를 확인할 수 없습니다.")
+                    return None, gr.update(interactive=False)
+                image = load_background_image(category, index)
+                if image is None:
+                    gr.Warning("선택한 배경 이미지를 불러오지 못했습니다.")
+                    return None, gr.update(interactive=False)
+                gr.Info("배경 이미지를 선택했습니다.")
+                ready = gr.update(interactive=bg_removed is not None)
+                return image, ready
+
+            def on_generate_background(
+                last_output: Optional[Image.Image],
+                selected_bg: Optional[Image.Image],
+                hq_mode: bool,
+                input_img: Optional[Image.Image],
+                current_bg_removed: Optional[Image.Image],
+                selected_face: Optional[Image.Image],
+            ):
+                if last_output is None:
+                    gr.Warning("먼저 배경 제거를 실행해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        last_output,
+                        gr.update(value=last_output),
+                        make_download_update(last_output),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                if selected_bg is None:
+                    gr.Warning("사용할 배경 이미지를 선택해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        last_output,
+                        gr.update(value=last_output),
+                        make_download_update(last_output),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
                 yield (
                     last_output,
                     gr.update(value=last_output),
                     make_download_update(last_output),
                     history_update(),
-                    remove_ready,
-                    video_ready,
-                    bg_ready,
-                    swap_ready,
+                    remove_disabled,
+                    video_disabled,
+                    bg_disabled,
+                    swap_disabled,
                 )
-                return
-
-            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
-            yield (
-                last_output,
-                gr.update(value=last_output),
-                make_download_update(last_output),
-                history_update(),
-                remove_disabled,
-                video_disabled,
-                bg_disabled,
-                swap_disabled,
-            )
 
-            generated, message = processor.generate_background(last_output, selected_bg, hq_mode)
-            if generated is None:
-                gr.Warning(message)
+                generated, message = processor.generate_background(last_output, selected_bg, hq_mode)
+                if generated is None:
+                    gr.Warning(message)
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        last_output,
+                        gr.update(value=last_output),
+                        make_download_update(last_output),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                gr.Info(message)
+                add_to_history(generated, "bg_gen")
                 remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
                     input_img,
-                    last_output,
+                    generated,
                     current_bg_removed,
                     selected_bg,
                     selected_face,
                 )
                 yield (
-                    last_output,
-                    gr.update(value=last_output),
-                    make_download_update(last_output),
+                    generated,
+                    gr.update(value=generated),
+                    make_download_update(generated, "background_generated"),
                     history_update(),
                     remove_ready,
                     video_ready,
                     bg_ready,
                     swap_ready,
                 )
-                return
-
-            gr.Info(message)
-            add_to_history(generated, "bg_gen")
-            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                input_img,
-                generated,
-                current_bg_removed,
-                selected_bg,
-                selected_face,
-            )
-            yield (
-                generated,
-                gr.update(value=generated),
-                make_download_update(generated, "background_generated"),
-                history_update(),
-                remove_ready,
-                video_ready,
-                bg_ready,
-                swap_ready,
-            )
 
-        def load_face_image(category: str, index: int) -> Optional[Image.Image]:
-            key = f"{category}_paths"
-            paths = face_images.get(key, [])
-            if 0 <= index < len(paths):
-                path = paths[index]
-                return load_full_image(path)
-            return None
+            def load_face_image(category: str, index: int) -> Optional[Image.Image]:
+                key = f"{category}_paths"
+                paths = face_images.get(key, [])
+                if 0 <= index < len(paths):
+                    path = paths[index]
+                    return load_full_image(path)
+                return None
 
-        def on_select_face(
-            evt: gr.SelectData,
-            category: str,
-            last_output: Optional[Image.Image],
-            input_img: Optional[Image.Image],
-        ):
-            base_image = last_output or input_img
-            index = getattr(evt, "index", None)
-            if index is None:
-                gr.Warning("선택 정보를 확인할 수 없습니다.")
-                return None, gr.update(interactive=False)
-            image = load_face_image(category, index)
-            if image is None:
-                gr.Warning("선택한 얼굴 이미지를 불러오지 못했습니다.")
-                return None, gr.update(interactive=False)
-            gr.Info("얼굴 이미지를 선택했습니다.")
-            ready = gr.update(interactive=base_image is not None)
-            return image, ready
-
-        def on_swap_face(
-            last_output: Optional[Image.Image],
-            input_img: Optional[Image.Image],
-            selected_face: Optional[Image.Image],
-            current_bg_removed: Optional[Image.Image],
-            selected_bg: Optional[Image.Image],
-        ):
-            base_image = last_output or input_img
-            if base_image is None:
-                gr.Warning("입력 이미지를 먼저 업로드해주세요.")
-                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                    input_img,
-                    last_output,
-                    current_bg_removed,
-                    selected_bg,
-                    selected_face,
-                )
+            def on_select_face(
+                evt: gr.SelectData,
+                category: str,
+                last_output: Optional[Image.Image],
+                input_img: Optional[Image.Image],
+            ):
+                base_image = last_output or input_img
+                index = getattr(evt, "index", None)
+                if index is None:
+                    gr.Warning("선택 정보를 확인할 수 없습니다.")
+                    return None, gr.update(interactive=False)
+                image = load_face_image(category, index)
+                if image is None:
+                    gr.Warning("선택한 얼굴 이미지를 불러오지 못했습니다.")
+                    return None, gr.update(interactive=False)
+                gr.Info("얼굴 이미지를 선택했습니다.")
+                ready = gr.update(interactive=base_image is not None)
+                return image, ready
+
+            def on_swap_face(
+                last_output: Optional[Image.Image],
+                input_img: Optional[Image.Image],
+                selected_face: Optional[Image.Image],
+                current_bg_removed: Optional[Image.Image],
+                selected_bg: Optional[Image.Image],
+            ):
+                base_image = last_output or input_img
+                if base_image is None:
+                    gr.Warning("입력 이미지를 먼저 업로드해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        last_output,
+                        gr.update(),
+                        make_download_update(last_output),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                if selected_face is None:
+                    gr.Warning("사용할 얼굴 이미지를 선택해주세요.")
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        last_output,
+                        gr.update(value=base_image),
+                        make_download_update(last_output),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
                 yield (
                     last_output,
-                    gr.update(),
+                    gr.update(value=base_image),
                     make_download_update(last_output),
                     history_update(),
-                    remove_ready,
-                    video_ready,
-                    bg_ready,
-                    swap_ready,
+                    remove_disabled,
+                    video_disabled,
+                    bg_disabled,
+                    swap_disabled,
                 )
-                return
 
-            if selected_face is None:
-                gr.Warning("사용할 얼굴 이미지를 선택해주세요.")
+                swapped, message = processor.swap_face(base_image, selected_face)
+                if swapped is None:
+                    gr.Warning(message)
+                    remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
+                        input_img,
+                        last_output,
+                        current_bg_removed,
+                        selected_bg,
+                        selected_face,
+                    )
+                    yield (
+                        last_output,
+                        gr.update(value=base_image),
+                        make_download_update(last_output),
+                        history_update(),
+                        remove_ready,
+                        video_ready,
+                        bg_ready,
+                        swap_ready,
+                    )
+                    return
+
+                gr.Info(message)
+                add_to_history(swapped, "face_swap")
                 remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
                     input_img,
-                    last_output,
+                    swapped,
                     current_bg_removed,
                     selected_bg,
                     selected_face,
                 )
                 yield (
-                    last_output,
-                    gr.update(value=base_image),
-                    make_download_update(last_output),
+                    swapped,
+                    gr.update(value=swapped),
+                    make_download_update(swapped, "face_swap"),
                     history_update(),
                     remove_ready,
                     video_ready,
                     bg_ready,
                     swap_ready,
                 )
-                return
-
-            remove_disabled, video_disabled, bg_disabled, swap_disabled = disable_all_buttons()
-            yield (
-                last_output,
-                gr.update(value=base_image),
-                make_download_update(last_output),
-                history_update(),
-                remove_disabled,
-                video_disabled,
-                bg_disabled,
-                swap_disabled,
+
+            input_image.change(
+                on_upload,
+                inputs=[input_image],
+                outputs=[
+                    input_state,
+                    bg_removed_state,
+                    selected_bg_state,
+                    selected_face_state,
+                    last_output_state,
+                    output_image,
+                    download_btn,
+                    video_output,
+                    remove_bg_btn,
+                    generate_video_btn,
+                    generate_bg_btn,
+                    swap_face_btn,
+                    history_gallery,
+                ],
             )
 
-            swapped, message = processor.swap_face(base_image, selected_face)
-            if swapped is None:
-                gr.Warning(message)
-                remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                    input_img,
-                    last_output,
-                    current_bg_removed,
-                    selected_bg,
-                    selected_face,
-                )
-                yield (
-                    last_output,
-                    gr.update(value=base_image),
-                    make_download_update(last_output),
-                    history_update(),
-                    remove_ready,
-                    video_ready,
-                    bg_ready,
-                    swap_ready,
-                )
-                return
-
-            gr.Info(message)
-            add_to_history(swapped, "face_swap")
-            remove_ready, video_ready, bg_ready, swap_ready = compute_button_states(
-                input_img,
-                swapped,
-                current_bg_removed,
-                selected_bg,
-                selected_face,
+            remove_bg_btn.click(
+                handle_remove_background,
+                inputs=[
+                    input_state,
+                    bg_removed_state,
+                    selected_bg_state,
+                    last_output_state,
+                    selected_face_state,
+                ],
+                outputs=[
+                    bg_removed_state,
+                    last_output_state,
+                    output_image,
+                    download_btn,
+                    generate_bg_btn,
+                    swap_face_btn,
+                    remove_bg_btn,
+                    generate_video_btn,
+                    history_gallery,
+                ],
             )
-            yield (
-                swapped,
-                gr.update(value=swapped),
-                make_download_update(swapped, "face_swap"),
-                history_update(),
-                remove_ready,
-                video_ready,
-                bg_ready,
-                swap_ready,
+
+            generate_video_btn.click(
+                on_generate_video,
+                inputs=[
+                    last_output_state,
+                    input_state,
+                    bg_removed_state,
+                    selected_bg_state,
+                    selected_face_state,
+                ],
+                outputs=[
+                    video_output,
+                    history_gallery,
+                    remove_bg_btn,
+                    generate_video_btn,
+                    generate_bg_btn,
+                    swap_face_btn,
+                ],
             )
 
-        input_image.change(
-            on_upload,
-            inputs=[input_image],
-            outputs=[
-                input_state,
-                bg_removed_state,
-                selected_bg_state,
-                selected_face_state,
-                last_output_state,
-                output_image,
-                download_btn,
-                video_output,
-                remove_bg_btn,
-                generate_video_btn,
-                generate_bg_btn,
-                swap_face_btn,
-                history_gallery,
-            ],
-        )
+            indoor_gallery.select(
+                on_select_background,
+                inputs=[gr.State("indoor"), bg_removed_state],
+                outputs=[selected_bg_state, generate_bg_btn],
+            )
 
-        remove_bg_btn.click(
-            handle_remove_background,
-            inputs=[
-                input_state,
-                bg_removed_state,
-                selected_bg_state,
-                last_output_state,
-                selected_face_state,
-            ],
-            outputs=[
-                bg_removed_state,
-                last_output_state,
-                output_image,
-                download_btn,
-                generate_bg_btn,
-                swap_face_btn,
-                remove_bg_btn,
-                generate_video_btn,
-                history_gallery,
-            ],
-        )
+            outdoor_gallery.select(
+                on_select_background,
+                inputs=[gr.State("outdoor"), bg_removed_state],
+                outputs=[selected_bg_state, generate_bg_btn],
+            )
 
-        generate_video_btn.click(
-            on_generate_video,
-            inputs=[
-                last_output_state,
-                input_state,
-                bg_removed_state,
-                selected_bg_state,
-                selected_face_state,
-            ],
-            outputs=[
-                video_output,
-                history_gallery,
-                remove_bg_btn,
-                generate_video_btn,
-                generate_bg_btn,
-                swap_face_btn,
-            ],
-        )
+            generate_bg_btn.click(
+                on_generate_background,
+                inputs=[
+                    last_output_state,
+                    selected_bg_state,
+                    hq_checkbox,
+                    input_state,
+                    bg_removed_state,
+                    selected_face_state,
+                ],
+                outputs=[
+                    last_output_state,
+                    output_image,
+                    download_btn,
+                    history_gallery,
+                    remove_bg_btn,
+                    generate_video_btn,
+                    generate_bg_btn,
+                    swap_face_btn,
+                ],
+            )
 
-        indoor_gallery.select(
-            on_select_background,
-            inputs=[gr.State("indoor"), bg_removed_state],
-            outputs=[selected_bg_state, generate_bg_btn],
-        )
+            man_gallery.select(
+                on_select_face,
+                inputs=[gr.State("man"), last_output_state, input_state],
+                outputs=[selected_face_state, swap_face_btn],
+            )
 
-        outdoor_gallery.select(
-            on_select_background,
-            inputs=[gr.State("outdoor"), bg_removed_state],
-            outputs=[selected_bg_state, generate_bg_btn],
-        )
+            woman_gallery.select(
+                on_select_face,
+                inputs=[gr.State("woman"), last_output_state, input_state],
+                outputs=[selected_face_state, swap_face_btn],
+            )
 
-        generate_bg_btn.click(
-            on_generate_background,
-            inputs=[
-                last_output_state,
-                selected_bg_state,
-                hq_checkbox,
-                input_state,
-                bg_removed_state,
-                selected_face_state,
-            ],
-            outputs=[
-                last_output_state,
-                output_image,
-                download_btn,
-                history_gallery,
-                remove_bg_btn,
-                generate_video_btn,
-                generate_bg_btn,
-                swap_face_btn,
-            ],
-        )
+            swap_face_btn.click(
+                on_swap_face,
+                inputs=[
+                    last_output_state,
+                    input_state,
+                    selected_face_state,
+                    bg_removed_state,
+                    selected_bg_state,
+                ],
+                outputs=[
+                    last_output_state,
+                    output_image,
+                    download_btn,
+                    history_gallery,
+                    remove_bg_btn,
+                    generate_video_btn,
+                    generate_bg_btn,
+                    swap_face_btn,
+                ],
+            )
 
-        man_gallery.select(
-            on_select_face,
-            inputs=[gr.State("man"), last_output_state, input_state],
-            outputs=[selected_face_state, swap_face_btn],
-        )
+        # 로그인/로그아웃 핸들러
+        def handle_login(username, password):
+            """로그인 처리"""
+            if username in ALLOWED_USERS and username == password:
+                return (
+                    gr.update(visible=False),  # 로그인 페이지 숨김
+                    gr.update(visible=True),   # 메인 페이지 표시
+                    username,                  # 세션에 사용자 저장
+                    gr.update(value="✅ 로그인 성공!")
+                )
+            return (
+                gr.update(visible=True),   # 로그인 페이지 유지
+                gr.update(visible=False),  # 메인 페이지 숨김
+                None,                      # 세션 초기화
+                gr.update(value="❌ 로그인 실패: 사용자명 또는 비밀번호가 올바르지 않습니다.")
+            )
+
+        def handle_logout():
+            """로그아웃 처리"""
+            return (
+                gr.update(visible=True),   # 로그인 페이지 표시
+                gr.update(visible=False),  # 메인 페이지 숨김
+                None,                      # 세션 초기화
+                gr.update(value="")        # 메시지 초기화
+            )
 
-        woman_gallery.select(
-            on_select_face,
-            inputs=[gr.State("woman"), last_output_state, input_state],
-            outputs=[selected_face_state, swap_face_btn],
+        # 로그인/로그아웃 이벤트 연결
+        login_btn.click(
+            handle_login,
+            inputs=[username_input, password_input],
+            outputs=[login_page, main_page, session_user, login_msg]
         )
 
-        swap_face_btn.click(
-            on_swap_face,
-            inputs=[
-                last_output_state,
-                input_state,
-                selected_face_state,
-                bg_removed_state,
-                selected_bg_state,
-            ],
-            outputs=[
-                last_output_state,
-                output_image,
-                download_btn,
-                history_gallery,
-                remove_bg_btn,
-                generate_video_btn,
-                generate_bg_btn,
-                swap_face_btn,
-            ],
+        logout_btn.click(
+            handle_logout,
+            outputs=[login_page, main_page, session_user, login_msg]
         )
 
 
@@ -1213,6 +1277,5 @@ if __name__ == "__main__":
     app.launch(
         share=True,
         show_error=True,
-        auth=auth_fn,
         ssr_mode=False
     )