Update app.py

app.py

@@ -1,604 +1,446 @@
-import json
-import os
+import sys
 import subprocess
+import os
 import shutil
-import threading
+import time
+import json
+import requests
 import re
+import threading
+import glob
 import traceback
-import zipfile
-
 from datetime import datetime
-from concurrent.futures import ThreadPoolExecutor, as_completed
 
 # ==========================================
-# 1. 配置与环境设置
+# 0. 环境自动修复
 # ==========================================
+def install_package(package, pip_name=None):
+    pip_name = pip_name or package
+    try:
+        __import__(package)
+    except ImportError:
+        print(f"📦 正在自动安装缺失库: {pip_name} ...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", pip_name])
 
+install_package("gradio")
+install_package("requests")
 
+import gradio as gr
 
+# ================= 配置区域 =================
 
+API_KEY = "5d8189fa5abf2d541fa69e4c56e94a49"  # API 密钥
+TASK_BASE_URL = "https://api.kie.ai/api/v1/jobs"
+UPLOAD_BASE_URL = "https://kieai.redpandaai.co/api/file-stream-upload"
 
+# 任务存储根目录 (建议挂载持久化存储)
+TASKS_ROOT_DIR = "motion_tasks_data"
 
+HEADERS = {
+    "Authorization": f"Bearer {API_KEY}"
+}
 
+MODEL_NAME = "kling-2.6/motion-control"
 
+# ================= 核心工具函数 (Kling API 逻辑) =================
 
+def ensure_video_resolution(video_path, logger_func):
+    """
+    使用 ffmpeg 检查并调整视频分辨率 (至少 720p)。
+    """
+    if not video_path: return None
+    
+    logger_func(f"🔍 正在检查视频分辨率: {os.path.basename(video_path)}")
+    output_path = os.path.splitext(video_path)[0] + "_720p.mp4"
+    
+    # 简单的 ffmpeg 命令：短边至少 720
+    cmd = [
+        "ffmpeg", "-y", "-i", video_path,
+        "-vf", "scale='if(gt(iw,ih),-2,720)':'if(gt(iw,ih),720,-2)'",
+        "-c:v", "libx264", "-preset", "fast", "-crf", "23",
+        "-c:a", "copy",
+        output_path
+    ]
+    
+    try:
+        # 尝试调用系统 ffmpeg
+        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        logger_func(f"✅ 视频已标准化为 720p: {os.path.basename(output_path)}")
+        return output_path
+    except Exception as e:
+        logger_func(f"⚠️ 分辨率调整失败 (可能缺少ffmpeg)，将使用原视频: {e}")
+        return video_path
 
-KIE_API_KEY = "5d8189fa5abf2d541fa69e4c56e94a49" 
-KIE_TASK_URL = "https://api.kie.ai/api/v1/jobs"
-KIE_UPLOAD_URL = "https://kieai.redpandaai.co/api/file-stream-upload"
-MOTION_MODEL = "kling-2.6/motion-control"
+def upload_file_to_kie(file_path, logger_func):
+    """上传文件到 KIE 服务器"""
+    if not file_path: return None
+    
+    file_name = os.path.basename(file_path)
+    # 文件名清洗
+    file_name = "".join(x for x in file_name if x.isalnum() or x in "._- ")
+    logger_func(f"⬆️ 正在上传: {file_name} ...")
+    
+    try:
+        files = {'file': (file_name, open(file_path, 'rb'))}
+        data = {'uploadPath': 'images/user-uploads', 'fileName': file_name}
+        
+        response = requests.post(UPLOAD_BASE_URL, headers=HEADERS, files=files, data=data, timeout=120)
+        result = response.json()
+        
+        if result.get("success") and result.get("code") == 200:
+            download_url = result["data"]["downloadUrl"]
+            logger_func("✅ 上传成功")
+            return download_url
+        else:
+            logger_func(f"❌ 上传失败: {result}")
+            return None
+    except Exception as e:
+        logger_func(f"❌ 上传异常: {e}")
+        return None
+
+def create_motion_task(image_url, video_url, prompt, logger_func):
+    """创建动作迁移任务"""
+    url = f"{TASK_BASE_URL}/createTask"
+    task_headers = HEADERS.copy()
+    task_headers["Content-Type"] = "application/json"
+    
+    payload = {
+        "model": MODEL_NAME,
+        "input": {
+            "prompt": prompt,
+            "input_urls": [image_url],
+            "video_urls": [video_url],
+            "character_orientation": "video",
+            "mode": "720p"
+        }
+    }
 
-# 本地存储根目录
-TASKS_ROOT_DIR = "tasks_data"
-MAX_WORKERS = 5  # 控制同时处理图片的并发数
+    try:
+        response = requests.post(url, headers=task_headers, json=payload, timeout=30)
+        data = response.json()
+        if data.get("code") == 200:
+            tid = data["data"]["taskId"]
+            logger_func(f"🚀 任务创建成功，TaskID: {tid}")
+            return tid
+        else:
+            logger_func(f"❌ API 拒绝任务: {data}")
+            return None
+    except Exception as e:
+        logger_func(f"❌ 请求异常: {e}")
+        return None
 
-# ==========================================
-# 2. 核心：任务管理器 (Task Manager)
-#    负责状态管理、日志读写、文件持久化
-# ==========================================
+def wait_for_result(task_id, logger_func):
+    """轮询任务结果"""
+    url = f"{TASK_BASE_URL}/recordInfo?taskId={task_id}"
+    start_time = time.time()
+    timeout = 900 # 15分钟超时
+    
+    logger_func("⏳ 开始轮询结果...")
+    
+    while True:
+        if time.time() - start_time > timeout:
+            return None, "Timeout"
+
+        try:
+            response = requests.get(url, headers=HEADERS, timeout=30)
+            data = response.json()
+            
+            if data.get("code") != 200:
+                time.sleep(5)
+                continue
+            
+            state = data["data"]["state"]
+            
+            if state == "success":
+                result_json = json.loads(data["data"]["resultJson"])
+                video_url = result_json["resultUrls"][0]
+                return video_url, "Success"
+            elif state == "fail":
+                fail_msg = data["data"].get("failMsg", "Unknown error")
+                return None, f"Fail: {fail_msg}"
+            
+            # logger_func(f"Generated State: {state}") # 可选：减少日志量
+            time.sleep(5)
+            
+        except Exception as e:
+            logger_func(f"⚠️ 轮询网络波动: {e}")
+            time.sleep(5)
+
+def download_video_to_local(url, save_path, logger_func):
+    """将生成的视频下载到本地文件夹，实现持久化"""
+    try:
+        logger_func(f"⬇️ 正在下载结果到本地...")
+        resp = requests.get(url, stream=True, timeout=60)
+        if resp.status_code == 200:
+            with open(save_path, 'wb') as f:
+                for chunk in resp.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            return True
+        return False
+    except Exception as e:
+        logger_func(f"❌ 下载保存失败: {e}")
+        return False
+
+# ================= V9.1 异步任务管理器 (Task Isolation) =================
 
 class TaskManager:
     def __init__(self, root_dir=TASKS_ROOT_DIR):
         self.root_dir = root_dir
         os.makedirs(self.root_dir, exist_ok=True)
 
-    def create_task(self, original_desc="motion_transfer"):
-        """创建一个新任务，返回任务ID和目录"""
+    def create_task(self, task_name_prefix="motion"):
         timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-        # 清理文件名中的非法字符
-        clean_desc = re.sub(r'[\\/*?:"<>|]', "", original_desc)[:20] or "task"
-        task_id = f"{timestamp}_{clean_desc}"
-        
+        task_id = f"{task_name_prefix}_{timestamp}"
         task_dir = os.path.join(self.root_dir, task_id)
         os.makedirs(task_dir, exist_ok=True)
-        os.makedirs(os.path.join(task_dir, "inputs"), exist_ok=True)
-        os.makedirs(os.path.join(task_dir, "outputs"), exist_ok=True)
         
-        # 初始化日志
-        with open(os.path.join(task_dir, "log.txt"), "w", encoding="utf-8") as f:
-            f.write(f"[{datetime.now().strftime('%H:%M:%S')}] 任务已创建: {task_id}\n")
-
-
-
-
-
-
-
+        # 结果子目录
+        os.makedirs(os.path.join(task_dir, "results"), exist_ok=True)
         
-        # 初始化状态
-        self.update_status(task_id, "queued", progress=0, gallery=[])
+        with open(os.path.join(task_dir, "log.txt"), "w", encoding="utf-8") as f:
+            f.write(f"[{datetime.now().strftime('%H:%M:%S')}] 任务创建成功: {task_id}\n")
         
+        self.update_status(task_id, "running")
         return task_id, task_dir
 
     def log(self, task_id, message):
-        """写入日志"""
         timestamp = datetime.now().strftime('%H:%M:%S')
-        print(f"[{task_id}] {message}")
         log_line = f"[{timestamp}] {message}\n"
         log_path = os.path.join(self.root_dir, task_id, "log.txt")
         try:
             with open(log_path, "a", encoding="utf-8") as f:
                 f.write(log_line)
         except: pass
+        print(f"[{task_id}] {message}") 
 
-
-
-
-
-    def update_status(self, task_id, status, progress=0, result_zip=None, gallery=None):
-        """更新状态JSON"""
+    def update_status(self, task_id, status):
         status_path = os.path.join(self.root_dir, task_id, "status.json")
-        
-        # 读取旧状态以保留 gallery 数据
-        current_data = {}
-        if os.path.exists(status_path):
-            try:
-                with open(status_path, 'r', encoding='utf-8') as f:
-                    current_data = json.load(f)
-            except: pass
-            
-        data = {
-            "status": status,
-            "last_update": time.time(),
-            "progress": progress,
-            "result_zip": result_zip or current_data.get("result_zip"),
-            "gallery": gallery if gallery is not None else current_data.get("gallery", [])
-        }
-        
+        data = { "status": status, "last_update": time.time() }
         with open(status_path, "w", encoding="utf-8") as f:
             json.dump(data, f)
 
     def get_task_info(self, task_id):
-        """获取任务详情用于UI展示"""
         task_dir = os.path.join(self.root_dir, task_id)
-        if not os.path.exists(task_dir):
-            return None
+        if not os.path.exists(task_dir): return None
         
-        # 读取日志
         log_content = ""
         try:
             with open(os.path.join(task_dir, "log.txt"), "r", encoding="utf-8") as f:
                 log_content = f.read()
         except: log_content = "日志读取中..."
         
-        # 读取状态
-        status_data = {"status": "unknown", "gallery": [], "result_zip": None}
-        try:
-            with open(os.path.join(task_dir, "status.json"), "r", encoding="utf-8") as f:
-                status_data = json.load(f)
-        except: pass
-
+        # 扫描结果文件夹中的所有视频
+        results_dir = os.path.join(task_dir, "results")
+        result_files = sorted(glob.glob(os.path.join(results_dir, "*.mp4")))
+        
         return {
             "id": task_id,
             "log": log_content,
-            "status": status_data.get("status"),
-            "gallery": status_data.get("gallery"),
-            "result_zip": status_data.get("result_zip")
+            "results": result_files
         }
 
     def list_tasks(self):
-        """列出所有任务"""
         if not os.path.exists(self.root_dir): return []
         tasks = [d for d in os.listdir(self.root_dir) if os.path.isdir(os.path.join(self.root_dir, d))]
-        # 按时间倒序
+        # 按修改时间倒序
         tasks.sort(key=lambda x: os.path.getmtime(os.path.join(self.root_dir, x)), reverse=True)
         return tasks
-
-    # 🔥🔥 新增方法：清空所有任务数据 🔥🔥
+        
     def clear_all_tasks(self):
         try:
-            # 物理删除根目录
-            if os.path.exists(self.root_dir):
-                shutil.rmtree(self.root_dir)
-            # 重建根目录
+            shutil.rmtree(self.root_dir)
             os.makedirs(self.root_dir, exist_ok=True)
-            return True, "✅ 存储已清空，所有历史任务已删除。"
+            return "✅ 已清空所有历史任务"
         except Exception as e:
-            return False, f"❌ 清空失败: {e}"
+            return f"❌ 清空失败: {e}"
 
 task_manager = TaskManager()
 
+# ================= 后台工作线程 (Worker) =================
 
-
-
-
-
-
-
-
-
-
-# ==========================================
-# 3. 业务逻辑 (Kie AI API)
-# ==========================================
-
-def ensure_video_resolution(video_path, output_dir):
-    """处理视频分辨率"""
-    if not video_path: return None
-    output_path = os.path.join(output_dir, "driver_720p.mp4")
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    
-    # 如果已经处理过，直接返回
-    if os.path.exists(output_path): return output_path
-
-
-
-
-
-
-
-
-
-
-
-    cmd = ["ffmpeg", "-y", "-i", video_path, "-vf", "scale='if(gt(iw,ih),-2,720)':'if(gt(iw,ih),720,-2)'", "-c:v", "libx264", "-preset", "fast", "-crf", "23", "-c:a", "copy", output_path]
-    try:
-        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        return output_path
-    except:
-        return video_path # 失败则返回原视频
-
-def upload_file_to_kie(file_path):
-    """上传文件到 Kie AI"""
-    if not file_path or not os.path.exists(file_path): return None
-    file_name = os.path.basename(file_path)
-    # 清洗文件名
-    file_name = "".join(x for x in file_name if x.isalnum() or x in "._- ")
-    try:
-        headers = {"Authorization": f"Bearer {KIE_API_KEY}"}
-        files = {'file': (file_name, open(file_path, 'rb'))}
-        data = {'uploadPath': 'images/user-uploads', 'fileName': file_name}
-        resp = requests.post(KIE_UPLOAD_URL, headers=headers, files=files, data=data, timeout=120)
-        if resp.json().get("success"):
-            return resp.json()["data"]["downloadUrl"]
-    except Exception as e:
-        print(f"上传异常: {e}")
-    return None
-
-def download_file(url, save_path):
-    """通用下载函数"""
-    try:
-        headers = {"User-Agent": "Mozilla/5.0"}
-        resp = requests.get(url, stream=True, headers=headers, timeout=300)
-        if resp.status_code == 200:
-            with open(save_path, "wb") as f:
-                for chunk in resp.iter_content(chunk_size=8192):
-                    f.write(chunk)
-            return True
-    except: pass
-    return False
-
-def run_single_kie_task(img_path, video_url, prompt, task_id):
-    """执行单个 Kie AI 任务"""
-    # 1. 上传图片
-    img_url = upload_file_to_kie(img_path)
-    if not img_url: return None, "Image Upload Failed"
-    
-    # 2. 创建任务
-    headers = {"Authorization": f"Bearer {KIE_API_KEY}", "Content-Type": "application/json"}
-    payload = {
-        "model": MOTION_MODEL,
-        "input": {
-            "prompt": prompt,
-            "input_urls": [img_url],
-            "video_urls": [video_url],
-            "character_orientation": "video",
-            "mode": "720p"
-        }
-    }
-    
-
-    try:
-        resp = requests.post(f"{KIE_TASK_URL}/createTask", headers=headers, json=payload, timeout=60)
-        if resp.json().get("code") != 200:
-            return None, f"Create Task Error: {resp.text}"
-        remote_task_id = resp.json()["data"]["taskId"]
-    except Exception as e:
-        return None, str(e)
-
-    # 3. 轮询
-    start_time = time.time()
-    while time.time() - start_time < 1800: # 30分钟超时
-
-
-        try:
-            r = requests.get(f"{KIE_TASK_URL}/recordInfo?taskId={remote_task_id}", headers=headers, timeout=30)
-            if r.status_code == 200:
-                d = r.json()
-                state = d.get("data", {}).get("state")
-
-                if state == "success":
-                    video_url = json.loads(d["data"]["resultJson"])["resultUrls"][0]
-                    return video_url, "Success"
-                elif state == "fail":
-                    return None, f"Kie Task Failed: {d.get('data', {}).get('failReason')}"
-            time.sleep(10)
-        except:
-            time.sleep(10)
-            
-    return None, "Timeout"
-
-# ==========================================
-# 4. 后台工作线程 (Worker)
-# ==========================================
-
-def background_worker(task_id, uploaded_images, video_path, prompt):
-    task_manager.update_status(task_id, "running", progress=0)
-    task_manager.log(task_id, "🚀 任务后台线程已启动")
-    
+def background_worker(task_id, images, video, prompt):
     task_dir = os.path.join(task_manager.root_dir, task_id)
-    input_dir = os.path.join(task_dir, "inputs")
-    output_dir = os.path.join(task_dir, "outputs")
-    
-    local_images = []
+    results_dir = os.path.join(task_dir, "results")
     
+    def log_wrapper(msg):
+        task_manager.log(task_id, msg)
+
     try:
-        # 1. 本地文件归档 (将上传的临时文件复制到任务目录)
-        task_manager.log(task_id, "📂 正在归档输入文件...")
+        log_wrapper("🚀 后台进程启动。即使刷新页面，任务也会继续运行。")
         
-        # 处理视频
-        local_video_path = os.path.join(input_dir, "driver_video.mp4")
-        shutil.copy(video_path, local_video_path)
+        if not images or not video:
+            log_wrapper("❌ 缺少图片或视频，任务终止。")
+            task_manager.update_status(task_id, "failed")
+            return
+
+        # 1. 本地文件准备 (复制到任务目录，防止gradio临时文件消失)
+        local_video_name = os.path.basename(video)
+        local_video_path = os.path.join(task_dir, local_video_name)
+        shutil.copy(video, local_video_path)
         
-        # 处理图片
-        for idx, img_file in enumerate(uploaded_images):
-            # 获取 Gradio File 对象的路径 (img_file 是临时路径字符串或对象)
-            src_path = img_file.name if hasattr(img_file, 'name') else img_file
-            fname = f"image_{idx:03d}{os.path.splitext(src_path)[1]}"
-            dst_path = os.path.join(input_dir, fname)
+        local_images = []
+        for img in images:
+            # 处理 Gradio 可能是文件对象或路径的情况
+            src_path = img.name if hasattr(img, 'name') else img
+            dst_path = os.path.join(task_dir, os.path.basename(src_path))
             shutil.copy(src_path, dst_path)
             local_images.append(dst_path)
-            
-        task_manager.log(task_id, f"✅ 文件归档完成。图片: {len(local_images)}张, 视频已保存。")
-        
-        # 2. 预处理驱动视频
-        task_manager.log(task_id, "🔧 正在检查/处理驱动视频分辨率...")
-        processed_video = ensure_video_resolution(local_video_path, input_dir)
+
+        # 2. 视频预处理
+        log_wrapper("--- 步骤 1: 检查并修复视频分辨率 ---")
+        processed_video = ensure_video_resolution(local_video_path, log_wrapper)
         
-        # 3. 上传驱动视频 (只上传一次)
-        task_manager.log(task_id, "☁️ 正在上传驱动视频到云端...")
-        video_public_url = upload_file_to_kie(processed_video)
+        # 3. 上传视频
+        log_wrapper("--- 步骤 2: 上传驱动视频 ---")
+        video_public_url = upload_file_to_kie(processed_video, log_wrapper)
         if not video_public_url:
-            raise Exception("驱动视频上传失败，请检查网络或Key")
-        task_manager.log(task_id, "✅ 驱动视频上传成功")
+            log_wrapper("❌ 视频上传失败，流程终止。")
+            task_manager.update_status(task_id, "failed")
+            return
 
-        # 4. 并发执行生成任务
-        total_imgs = len(local_images)
-        finished_count = 0
-        success_results = [] # 存储本地生成的视频路径
+        # 4. 循环处理图片
+        total = len(local_images)
+        success_count = 0
         
-        task_manager.log(task_id, f"🚀 开始并发生成，线程数: {MAX_WORKERS}")
-        
-        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
-            # 提交所有任务
-            future_map = {}
-            for i, img_path in enumerate(local_images):
-                img_name = os.path.basename(img_path)
-                task_manager.log(task_id, f"➕ 提交子任务: {img_name}")
-                future = executor.submit(run_single_kie_task, img_path, video_public_url, prompt, task_id)
-                future_map[future] = (i, img_name)
+        for i, img_path in enumerate(local_images):
+            log_wrapper(f"\n🎥 [处理进度 {i+1}/{total}] 图片: {os.path.basename(img_path)}")
             
-            # 等待结果
-            for future in as_completed(future_map):
-                idx, img_name = future_map[future]
-                try:
-                    video_url, msg = future.result()
-                    if video_url:
-                        # 下载结果
-                        save_name = f"result_{idx:03d}_{int(time.time())}.mp4"
-                        save_path = os.path.join(output_dir, save_name)
-                        if download_file(video_url, save_path):
-                            success_results.append(save_path)
-                            task_manager.log(task_id, f"✅ [成功] {img_name} -> {save_name}")
-                        else:
-                            task_manager.log(task_id, f"⚠️ [下载失败] {img_name}")
-                    else:
-                        task_manager.log(task_id, f"❌ [生成失败] {img_name}: {msg}")
-                except Exception as e:
-                    task_manager.log(task_id, f"❌ [异常] {img_name}: {e}")
+            # 上传图片
+            img_public_url = upload_file_to_kie(img_path, log_wrapper)
+            if not img_public_url:
+                continue
                 
-                finished_count += 1
-                # 更新进度条
-                progress_val = int((finished_count / total_imgs) * 100)
-                # 实时更新 Gallery
-                current_gallery = success_results.copy()
-                task_manager.update_status(task_id, "running", progress=progress_val, gallery=current_gallery)
-
-        # 5. 打包结果
-        if success_results:
-            zip_name = f"Pack_{task_id}.zip"
-            zip_path = os.path.join(task_dir, zip_name)
-            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zf:
-                for f in success_results:
-                    zf.write(f, os.path.basename(f))
+            # 创建任务
+            api_task_id = create_motion_task(img_public_url, video_public_url, prompt, log_wrapper)
             
-            task_manager.log(task_id, f"📦 所有任务完成。打包成功: {zip_name}")
-            task_manager.update_status(task_id, "completed", progress=100, result_zip=zip_path, gallery=success_results)
-        else:
-            task_manager.log(task_id, "❌ 所有任务均失败，无结果生成。")
-            task_manager.update_status(task_id, "failed", progress=100)
+            if api_task_id:
+                # 等待结果
+                final_video_url, msg = wait_for_result(api_task_id, log_wrapper)
+                
+                if final_video_url:
+                    log_wrapper("✅ 生成成功，正在下载...")
+                    # 保存文件名: output_01_origName.mp4
+                    save_name = f"output_{i+1:02d}_{os.path.basename(img_path).split('.')[0]}.mp4"
+                    save_full_path = os.path.join(results_dir, save_name)
+                    
+                    if download_video_to_local(final_video_url, save_full_path, log_wrapper):
+                        log_wrapper(f"💾 已保存到: {save_name}")
+                        success_count += 1
+                    else:
+                        log_wrapper("⚠️ 下载失败，仅提供链接")
+                else:
+                    log_wrapper(f"❌ 生成失败: {msg}")
+            else:
+                log_wrapper("❌ 任务创建失败")
+        
+        log_wrapper(f"\n🎉 任务结束。成功: {success_count}/{total}")
+        task_manager.update_status(task_id, "completed")
 
     except Exception as e:
-        err_msg = traceback.format_exc()
-        task_manager.log(task_id, f"💥 致命错误: {err_msg}")
+        log_wrapper(f"💥 致命错误: {traceback.format_exc()}")
         task_manager.update_status(task_id, "error")
 
-# ==========================================
-# 5. UI 交互层
-# ==========================================
+# ================= 交互逻辑 =================
 
-
-
-
-def submit_task_ui(images, video, prompt):
-    if not images: return "❌ 未上传图片", None
-    if not video: return "❌ 未上传视频", None
+def submit_new_task(images, video, prompt):
+    if not images: return "❌ 请上传至少一张图片", None
+    if not video: return "❌ 请上传参考视频", None
     
-    # 创建任务
-    task_desc = f"Batch_{len(images)}imgs"
-    task_id, task_dir = task_manager.create_task(task_desc)
+    # 任务名以第一张图片命名
+    first_img_name = os.path.basename(images[0].name if hasattr(images[0], 'name') else images[0])
+    task_name = f"motion_{first_img_name[:10]}"
     
-    # 启动后台线程
+    task_id, task_dir = task_manager.create_task(task_name)
+    
+    # 启动线程
     t = threading.Thread(target=background_worker, args=(task_id, images, video, prompt))
     t.start()
     
-    return f"✅ 任务已后台启动！ID: {task_id}\n请切换到【任务监控】标签查看进度。", task_id
-
-def refresh_task_list_ui():
-    choices = task_manager.list_tasks()
-    return gr.Dropdown(choices=choices, value=choices[0] if choices else None)
+    return f"✅ 任务已后台启动！ID: {task_id}\n请切换到【任务监控】标签页查看进度。", task_id
 
+def refresh_task_list():
+    tasks = task_manager.list_tasks()
+    return gr.Dropdown(choices=tasks, value=tasks[0] if tasks else None)
 
-def get_task_details_ui(task_id):
+def get_task_details(task_id):
+    if not task_id: return "请选择任务", []
     info = task_manager.get_task_info(task_id)
-    if not info:
-        return "未选择任务", [], None, "状态: 未知"
+    if not info: return "任务不存在", []
     
-    status_text = f"状态: {info['status']}"
-    # 返回: 日志内容, Gallery列表, 下载文件, 状态标签
-    return info['log'], info['gallery'], info['result_zip'], status_text
+    # 返回: 日志内容, 结果文件列表(用于Gallery)
+    return info['log'], info['results']
 
-# 🔥🔥 新增函数：处理清空储存的逻辑 🔥🔥
 def handle_clear_storage():
-    success, msg = task_manager.clear_all_tasks()
-    # 清空后，需要重置 UI 组件：清空下拉列表、清空日志、清空画廊、清空下载链接、重置状态
-    return msg, gr.Dropdown(choices=[], value=None), "", [], None, "状态: 已清空"
-
-
-
-
-
-
-
-
-
-
-
-
+    msg = task_manager.clear_all_tasks()
+    return msg, gr.Dropdown(choices=[], value=None)
 
+# ================= UI 构建 =================
 
-
-
-
-# ==========================================
-# 6. Gradio App
-# ==========================================
-
-with gr.Blocks(title="Kie AI 异步批量动作迁移") as demo:
-    gr.Markdown("## ⚡️ Kie AI 批量动作迁移 - 异步后台版")
-    gr.Markdown("提交任务后可关闭页面，任务会在后台继续运行。刷新页面后在“任务监控”中查看结果。")
-
+with gr.Blocks(title="Kling Motion V9.1 Async") as demo:
+    gr.Markdown("## 💃 Kling 动作迁移批量工厂 (V9.1 异步防断连版)")
+    gr.Markdown("**特性**：支持多任务并发、刷新页面不中断、结果自动保存到硬盘、视频分辨率自动修复。")
+    
     with gr.Tabs():
-        # --- 提交页面 ---
+        # --- Tab 1: 提交任务 ---
         with gr.Tab("🚀 提交新任务"):
             with gr.Row():
                 with gr.Column():
-                    img_input = gr.File(label="1. 上传图片 (多选)", file_count="multiple", type="filepath", height=200)
-                    video_input = gr.Video(label="2. 上传驱动视频", format="mp4", height=200)
-                    prompt_input = gr.Textbox(label="动作描述", value="The character matches the pose and motion of the video reference.", lines=2)
-                    submit_btn = gr.Button("开始后台任务", variant="primary")
+                    img_input = gr.File(label="1. 上传图片 (支持多选)", file_count="multiple", file_types=["image"])
+                    video_input = gr.Video(label="2. 上传参考视频", format="mp4")
+                    prompt_input = gr.Textbox(label="3. 提示词", value="The character is performing the action from the video.")
+                    submit_btn = gr.Button("🔥 立即启动后台任务", variant="primary")
                 with gr.Column():
-                    submit_output = gr.Textbox(label="提交结果", lines=4)
-                    # 隐藏状态用于自动跳转
-                    new_task_id_state = gr.State()
+                    submit_result = gr.Textbox(label="提交结果", lines=2)
+                    new_task_id_storage = gr.State()
 
-        # --- 监控页面 ---
+        # --- Tab 2: 监控任务 ---
         with gr.Tab("📺 任务监控"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    refresh_btn = gr.Button("🔄 刷新任务列表")
-                    task_selector = gr.Dropdown(label="选择历史任务", choices=[], interactive=True)
-                    status_label = gr.Label("当前状态")
-                    download_btn = gr.File(label="📦 下载打包结果 (ZIP)")
+                    refresh_list_btn = gr.Button("🔄 刷新任务列表")
+                    task_dropdown = gr.Dropdown(label="选择历史任务", choices=[], interactive=True)
                     
-                    # 🔥🔥🔥 新增：清空按钮区域 🔥🔥🔥
-                    gr.Markdown("---") # 分割线
-                    clear_btn = gr.Button("🗑️ 危险：清空所有任务数据", variant="stop")
-                    clear_msg = gr.Label(label="��作结果") # 显示清空成功/失败的消息
-                
-                with gr.Column(scale=3):
-                    # 实时预览
-                    gallery_view = gr.Gallery(label="生成结果预览", columns=4, height="auto", object_fit="contain", interactive=False)
-                    # 日志
-                    log_view = gr.Textbox(label="运行日志", lines=15, max_lines=15, elem_id="log_box")
+                    gr.Markdown("### 📥 结果展示")
+                    # Gallery 直接展示本地文件路径，Gradio 会自动处理 serving
+                    result_gallery = gr.Gallery(label="生成结果 (本地保存)", columns=2, height="auto", allow_preview=True)
                     
-                    # 自动刷新器 (每2秒刷新一次详情)
-                    timer = gr.Timer(2)
+                    gr.Markdown("---")
+                    clear_btn = gr.Button("🗑️ 清空所有任务", variant="stop")
+                    clear_msg = gr.Label("")
+                    
+                with gr.Column(scale=2):
+                    log_monitor = gr.Textbox(label="运行日志 (自动刷新)", lines=25, max_lines=25)
+                    auto_timer = gr.Timer(2) # 2秒刷新一次
 
     # --- 事件绑定 ---
-    
-    # 1. 提交任务
+
+    # 提交
     submit_btn.click(
-        submit_task_ui,
-        inputs=[img_input, video_input, prompt_input],
-        outputs=[submit_output, new_task_id_state]
+        submit_new_task, 
+        [img_input, video_input, prompt_input], 
+        [submit_result, new_task_id_storage]
     )
-    
-    # 提交后自动选中新任务 (通过 js 或更新 dropdown)
-    def auto_select_new(task_id):
-        tasks = task_manager.list_tasks()
-        return gr.Dropdown(choices=tasks, value=task_id)
-    
-    submit_btn.click(auto_select_new, inputs=[new_task_id_state], outputs=[task_selector])
 
-    # 2. 刷新列表
-    refresh_btn.click(refresh_task_list_ui, outputs=[task_selector])
+    # 提交成功后，自动更新下拉框并选中新任务
+    def auto_select_new_task(new_id):
+        all_tasks = task_manager.list_tasks()
+        return gr.Dropdown(choices=all_tasks, value=new_id)
     
-    # 3. 页面加载时刷新列表
-    demo.load(refresh_task_list_ui, outputs=[task_selector])
-
-
-
+    submit_btn.click(auto_select_new_task, new_task_id_storage, task_dropdown)
 
+    # 刷新列表
+    refresh_list_btn.click(refresh_task_list, outputs=task_dropdown)
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-    # 4. 选中任务或定时器触发 -> 更新详情
-    task_selector.change(get_task_details_ui, inputs=[task_selector], outputs=[log_view, gallery_view, download_btn, status_label])
-    timer.tick(get_task_details_ui, inputs=[task_selector], outputs=[log_view, gallery_view, download_btn, status_label])
+    # 定时刷新日志和画廊
+    # 注意：outputs 对应 [日志框, 画廊组件]
+    auto_timer.tick(get_task_details, inputs=[task_dropdown], outputs=[log_monitor, result_gallery])
+    task_dropdown.change(get_task_details, inputs=[task_dropdown], outputs=[log_monitor, result_gallery])
     
-    # 🔥🔥🔥 5. 绑定清空按钮事件 🔥🔥🔥
-    # 点击按钮 -> 调用 handle_clear_storage -> 更新：消息、下拉列表、日志、画廊、下载文件、状态标签
-    clear_btn.click(
-        handle_clear_storage,
-        outputs=[clear_msg, task_selector, log_view, gallery_view, download_btn, status_label]
-    )
+    # 清空
+    clear_btn.click(handle_clear_storage, outputs=[clear_msg, task_dropdown])
+
+    # 初始化
+    demo.load(refresh_task_list, outputs=task_dropdown)
 
 if __name__ == "__main__":
-    # 允许访问 tasks_data 目录以便显示图片
-    demo.queue().launch(
-        server_name="0.0.0.0", 
-        inbrowser=True, 
-        allowed_paths=[TASKS_ROOT_DIR, "tasks_data"]
-    )
+    demo.queue().launch(server_name="0.0.0.0", inbrowser=True)