Upload ff2.py

ff2.py

@@ -0,0 +1,761 @@
+import subprocess
+import os
+import threading
+import time
+import yaml
+from datetime import datetime
+import signal
+import psutil
+import glob
+import re
+import pytz
+import requests
+import json
+import random
+import string
+import urllib3
+
+DATA_JSON = os.environ.get('DATA_JSON', '')
+HF_SPACES_NAME = os.environ.get('HF_SPACES_NAME', '')# 上个spaces名
+def assign_vars_from_json(config: dict):
+    for key, value in config.items():
+        globals()[key] = value
+
+if DATA_JSON:  # 如果 DATA_JSON 有值
+    try:
+        config_dict = json.loads(DATA_JSON)  # 解析 JSON 字符串
+        assign_vars_from_json(config_dict)
+    except json.JSONDecodeError:
+        raise ValueError("DATA_JSON 环境变量不是合法的 JSON 字符串")
+else:  # 如果 DATA_JSON 为空，就从单独的环境变量里取
+    BACKUP_TIME = os.environ.get('BACKUP_TIME', '1200')  # 备份时间 10800秒 2小时
+    HF_USER1 = os.environ.get('HF_USER1', '')  # HF 备份仓库的用户名
+    HF_REPO = os.environ.get('HF_REPO', '')  # HF 备份的Models仓库名
+    HF_EMAIL = os.environ.get('HF_EMAIL', '')  # HF的邮箱
+    HF_TOKEN1 = os.environ.get('HF_TOKEN1', '')  # HF备份账号的TOKEN
+    
+    HF_USER2 = os.environ.get('HF_USER2', '')  # huggingface 用户名
+    HF_ID = os.environ.get('HF_ID', '')  # huggingface space 名
+    HF_TOKON2 = os.environ.get('HF_TOKON2', '')  # huggingface TOKEN
+    HF_EMAIL2 = os.environ.get('HF_EMAIL2', '')  # HF的邮箱
+    
+    UUID = os.environ.get('UUID', 'a488076d-0ced-4a83-91c4-c498fce00cff')  # UUID,如使用v1,在不同的平台部署需要修改,否则会覆盖
+    N_SERVER = os.environ.get('N_SERVER', 'z.282820.xyz:443')# N面板域名或ip, 
+
+    CHAT_ID = os.environ.get('CHAT_ID', '')# Telegram chat_id,推送通知
+    BOT_TOKEN = os.environ.get('BOT_TOKEN', '')# Telegram bot_token
+
+
+
+def cf():
+    os.system("rm -r /data/cf")
+    os.system("wget -O '/data/cf' -q 'https://github.com/cloudflare/cloudflared/releases/download/2025.9.0/cloudflared-linux-amd64'")
+    os.system("chmod +x  /data/cf")
+    # https://ff1.vv9.dpdns.org
+    os.system('/data/cf tunnel run --token eyJhIjoiZWM1MTk5ZTYwZGYxYWI2YmM2OTdhMGYzMTAzYzY4NTUiLCJ0IjoiNDBmNjFiZGQtMzQyYS00MDYzLWJlZTQtZGU4ZjEyNDk2NTAwIiwicyI6Ik9HVXdNR0UyTWpVdFlUVmpOUzAwTlRCbExUZzRabVl0TldRNU9USTFNR1F3TjJabSJ9')
+
+UUID = os.environ.get('UUID', 'a488076d-0ced-4a83-91c4-c498fce00cff')  # UUID,如使用v1,在不同的平台部署需要修改,否则会覆盖
+N_SERVER = os.environ.get('NEZHA_SERVER', '')# N面板域名或ip, 
+def nv1():
+    agent_config = {
+        'client_secret': 'MLcD6YnifhoY08B9n129UP5cg2139NYa',
+        'debug': False,
+        'disable_auto_update': True,
+        'disable_command_execute': False,
+        'disable_force_update': False,
+        'disable_nat': False,
+        'disable_send_query': False,
+        'gpu': False,
+        'insecure_tls': False,
+        'ip_report_period': 1800,
+        'report_delay': 3,
+        'self_update_period': 0,
+        'server': 'z.282820.xyz:443',
+        'skip_connection_count': False,
+        'skip_procs_count': False,
+        'temperature': True,
+        'tls': True,
+        'use_gitee_to_upgrade': False,
+        'use_ipv6_country_code': False,
+        'uuid': UUID
+    }
+    with open('./config.yaml', 'w') as file:
+        yaml.dump(agent_config, file, default_flow_style=False)
+    
+    os.system("cat ./config.yaml")
+    os.system("rm -rf f1")
+    os.system("wget -O 'f1' -q 'https://huggingface.co/datasets/Qilan2/st-server/resolve/main/nv1amd64?download=true'")
+    os.system("chmod +x  f1")
+    os.system('./f1 -c ./config.yaml')
+    os.system('./f1 -c ./config.yaml')
+threading.Thread(target=nv1, daemon=True).start()
+threading.Thread(target=cf, daemon=True).start()
+
+def random_name(length=8):
+    return ''.join(random.choices(string.ascii_lowercase, k=length))
+
+def update_value(data: dict, key: str, new_value: str) -> dict:
+    if key in data:
+        data[key] = new_value
+    else:
+        print(f"!!! Key '{key}' ON")
+    return data
+def telegram_message(bot_token: str, chat_id: str, message: str):
+    """
+    发送 Telegram 通知消息
+    :param bot_token: 你的 Telegram Bot Token
+    :param chat_id: 接收消息的 chat_id
+    :param escaped_name: 节点名称（会显示在标题里）
+    :param message: 要发送的正文内容
+    :return: Telegram API 返回的结果
+    """
+    url = f"https://tgbotapi.9.c.5.b.0.d.0.0.1.0.a.2.ip6.arpa/bot{bot_token}/sendMessage"
+    params = {
+        "chat_id": chat_id,
+        "text": message,
+        "parse_mode": "MarkdownV2"
+    }
+    urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+    response = requests.post(url, params=params, verify=False)
+    try:
+        return response.json()
+    except Exception:
+        return {"status_code": response.status_code, "text": response.text}
+
+def create_space(type,key = "", value = "",name = ""):
+    if type == 1:
+        # 创建spaces
+        url = "https://huggingface.co/api/repos/create"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        name = random_name()
+        payload = {
+        "name": name,
+        "type": "space",
+        "private": True,
+        "sleepTimeSeconds": 172800,
+        # "template": "SpacesExamples/jupyterlab",
+        "sdk": "docker"
+      }
+      # "template": "SpacesExamples/jupyterlab",
+        response = requests.post(url, headers=headers, json=payload)
+        return response.json()
+    if type == 2:
+        # 删除spaces
+        url = "https://huggingface.co/api/repos/delete"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        payload = {
+            "organization": HF_USER2,
+            "name": name,
+            "type": "space"
+        }
+        response = requests.delete(url, headers=headers, json=payload)
+        return response.text
+    if type == 3:
+        # 创建spaces 变量
+        url = f"https://huggingface.co/api/spaces/{HF_USER2}/{name}/secrets"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        payload = {
+        "key": key,
+        "value": value,
+        "description": ""
+    }
+        response = requests.post(url, headers=headers, json=payload)
+        return response.text
+    if type == 4:
+        file_path = f"/data/{name}/Dockerfile"
+        os.system("rm -rf {HF_SPACES_NAME}")
+        git = f"git clone https://{HF_USER2}:{HF_TOKON2}@huggingface.co/spaces/{HF_USER2}/{name} /data/{name}"
+        url = "https://huggingface.co/datasets/Qilan2/ff/raw/main/Dockerfile"
+        print(git)
+        os.system(git)
+        os.system(f'git config --global user.email "{HF_EMAIL2}"')
+        os.system(f'git config --global user.name "{HF_USER2}"') 
+        os.chdir(f'/data/{name}')
+        os.system(f"rm -rf {file_path}")
+        time.sleep(3)
+        # 如果文件已存在，先删除
+        if os.path.exists(file_path):
+            print(f"文件已存在，删除: {file_path}")
+            os.remove(file_path)
+        print(f"正在下载 {url} 到 {file_path}")
+        response = requests.get(url)
+        if response.status_code == 200:
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+            with open(file_path, "wb") as f:
+                f.write(response.content)
+            print("下载完成 ✅")
+            # telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}下载Dockerfile 结果：下载完成 ✅")
+        else:
+            print(f"下载失败，状态码: {response.status_code}")
+            # telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}下载Dockerfile下载失败，状态码: {response.status_code}")
+        
+        # os.system(f"wget -O '/data/{tmp_name}/Dockerfile' https://huggingface.co/datasets/Qilan2/ff/raw/main/Dockerfile")
+        repo_path = f"/data/{name}"
+        subprocess.run(["git", "-C", repo_path, "add", "."], check=True)
+        subprocess.run(["git", "-C", repo_path, "commit", "-m", "0"], check=True)
+        subprocess.run(["git", "-C", repo_path, "push", "origin", "main"], check=True)
+        # os.system('git add .')
+        # os.system('git commit -m "0"')
+        # push_result = os.system('git push origin main')
+        # if push_result != 0:
+        #     print("推送失败，可能有冲突，尝试拉取并合并...")
+        #     os.system('git pull origin main --rebase')
+        #     os.system('git push origin main')
+    if type == 5:
+            # 获取用户的所有空间
+        headers = {
+            "Authorization": f"Bearer {HF_TOKON2}"
+        }
+        
+        # 获取用户的所有空间列表
+        response = requests.get(f"https://huggingface.co/api/spaces?author={HF_USER2}", headers=headers)
+        
+        if response.status_code != 200:
+            print(f"获取空间列表失败：{response.status_code}")
+            return
+        
+        spaces = response.json()
+        
+        # 按创建时间排序
+        spaces_sorted = sorted(spaces, key=lambda x: x['createdAt'], reverse=True)
+        
+        # 保留最新的空间
+        if len(spaces_sorted) > 1:
+            latest_space = spaces_sorted[0]
+            
+            # 遍历并删除其他旧空间
+            for space in spaces_sorted[1:]:
+                full_name = space['id']
+                space_id = full_name.split("/")[-1]
+                # 删除spaces
+                url = "https://huggingface.co/api/repos/delete"
+                headers = {
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {HF_TOKON2}"
+                }
+                payload = {
+                    "organization": HF_USER2,
+                    "name": space_id,
+                    "type": "space"
+                }
+                delete_response = requests.delete(url, headers=headers, json=payload)             
+                if delete_response.status_code == 200:
+                    print(f"成功删除空间：{space_id}")
+                    telegram_message(BOT_TOKEN, CHAT_ID, f"delete={space_id}=OK")
+                else:
+                    print(f"删除空间 {space_id} 失败：{delete_response.status_code}")
+                    telegram_message(BOT_TOKEN, CHAT_ID, f"delete={space_id}=ON")
+def get_latest_local_package(directory, pattern='*.tar.gz'):
+    try:
+        # 构建完整的搜索路径
+        search_pattern = os.path.join(directory, pattern)
+        
+        # 查找所有匹配的文件
+        files = glob.glob(search_pattern)
+        
+        if not files:
+            print("未找到匹配的 nezha-hf 压缩包")
+            return None
+        
+        # 获取最新的文件
+        latest_file = max(files, key=os.path.getmtime)
+        
+        print(f"找到最新的包: {latest_file}")
+        return latest_file
+    
+    except Exception as e:
+        print(f"获取最新包时发生错误: {e}")
+        return None
+
+
+def delete_huggingface_lfs_file(filename, repo_id, token):
+    """
+    通过Hugging Face API删除LFS文件记录
+    """
+    try:
+        # 1. 查询LFS文件列表
+        url = f"https://huggingface.co/api/models/{repo_id}/lfs-files"
+        headers = {
+            "content-type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        
+        response = requests.get(url, headers=headers)
+        if response.status_code != 200:
+            print(f"查询LFS文件失败: {response.status_code} - {response.text}")
+            return False
+        
+        lfs_files = response.json()
+        
+        # 2. 查找匹配的文件
+        file_to_delete = None
+        for file_info in lfs_files:
+            if file_info.get('filename') == filename:
+                file_to_delete = file_info
+                break
+        
+        if not file_to_delete:
+            print(f"未找到对应的LFS文件记录: {filename}")
+            return False
+        
+        # 3. 删除LFS文件记录
+        file_oid = file_to_delete['fileOid']
+        delete_url = f"https://huggingface.co/api/models/{repo_id}/lfs-files/{file_oid}?rewriteHistory=true"
+        
+        delete_response = requests.delete(delete_url, headers=headers)
+        if delete_response.status_code == 200:
+            print(f"成功删除LFS文件记录: {filename} (OID: {file_oid})")
+            return True
+        else:
+            print(f"删除LFS文件记录失败: {delete_response.status_code} - {delete_response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"删除LFS文件记录时出错: {e}")
+        return False
+
+
+def safe_git_cleanup(repo_path, files_to_remove):
+    """
+    安全的Git清理，不会影响现有的备份文件
+    """
+    try:
+        original_dir = os.getcwd()
+        os.chdir(repo_path)
+        
+        print(f"执行安全Git清理: {files_to_remove}")
+        
+        # 1. 首先确保工作目录是干净的
+        result = subprocess.run(['git', 'status', '--porcelain'], capture_output=True, text=True)
+        if result.stdout.strip():
+            print("工作目录有未提交的更改，先提交...")
+            subprocess.run(['git', 'add', '.'], capture_output=True)
+            subprocess.run(['git', 'commit', '-m', '自动提交: 清理前的更改'], capture_output=True)
+        
+        # 2. 只从Git索引中删除指定的文件，但不影响工作目录中的文件
+        for filename in files_to_remove:
+            if os.path.exists(filename):
+                print(f"从Git索引中删除 {filename} (文件仍保留在工作目录)")
+                subprocess.run(['git', 'rm', '--cached', filename], capture_output=True)
+            else:
+                print(f"文件 {filename} 不存在于工作目录，只清理Git引用")
+        
+        # 3. 提交删除操作
+        if files_to_remove:
+            subprocess.run(['git', 'commit', '-m', f'清理已删除的文件: {", ".join(files_to_remove)}'], capture_output=True)
+        
+        # 4. 执行GC清理但不删除最近的文件
+        subprocess.run(['git', 'gc', '--auto'], capture_output=True)
+        subprocess.run(['git', 'lfs', 'prune'], capture_output=True)
+        
+        print("安全Git清理完成")
+        os.chdir(original_dir)
+        return True
+        
+    except Exception as e:
+        print(f"安全Git清理时出错: {e}")
+        os.chdir(original_dir)
+        return False
+
+
+def get_remote_lfs_files(repo_id, token):
+    """
+    获取远程所有的LFS文件列表
+    """
+    try:
+        url = f"https://huggingface.co/api/models/{repo_id}/lfs-files"
+        headers = {
+            "content-type": "application/json",
+            "Authorization": f"Bearer {token}",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"获取远程LFS文件失败: {response.status_code}")
+            return []
+    except Exception as e:
+        print(f"获取远程LFS文件时出错: {e}")
+        return []
+
+
+def cleanup_orphaned_lfs_references(repo_path, repo_id, token, keep_count=3):
+    """
+    清理孤儿LFS引用：删除远程存在但本地不存在的文件引用
+    """
+    try:
+        original_dir = os.getcwd()
+        os.chdir(repo_path)
+        
+        print("检查孤儿LFS引用...")
+        
+        # 获取远程LFS文件
+        remote_files = get_remote_lfs_files(repo_id, token)
+        if not remote_files:
+            print("无法获取远程LFS文件列表")
+            return
+        
+        # 获取本地文件
+        local_files = set(glob.glob('*.tar.gz'))
+        
+        # 找出远程存在但本地不存在的文件
+        orphaned_files = []
+        for remote_file in remote_files:
+            filename = remote_file.get('filename')
+            if filename and filename not in local_files:
+                orphaned_files.append(filename)
+        
+        if orphaned_files:
+            print(f"发现孤儿LFS引用: {orphaned_files}")
+            
+            # 删除这些孤儿引用
+            for filename in orphaned_files:
+                print(f"删除孤儿LFS引用: {filename}")
+                delete_huggingface_lfs_file(filename, repo_id, token)
+        
+        print("孤儿LFS引用清理完成")
+        os.chdir(original_dir)
+        
+    except Exception as e:
+        print(f"清理孤儿LFS引用时出错: {e}")
+        os.chdir(original_dir)
+
+
+def compress_folder(folder_path, output_dir, keep_count=3):
+    try:
+        # 确保输出目录存在
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # 设置中国时区
+        china_tz = pytz.timezone('Asia/Shanghai')
+        
+        # 获取当前中国时间
+        current_time = datetime.now(china_tz)
+        timestamp = str(int(current_time.timestamp() * 1000))
+        current_date = current_time.strftime('%Y-%m-%d')
+        output_path = os.path.join(output_dir, f'{timestamp}.tar.gz')
+        
+        # 获取所有压缩包
+        existing_archives = glob.glob(os.path.join(output_dir, '*.tar.gz'))
+        
+        # 安全地提取时间戳和日期
+        def extract_timestamp(filename):
+            match = re.search(r'(\d+)\.tar\.gz$', filename)
+            return int(match.group(1)) if match else 0
+            
+        def get_date_from_timestamp(ts):
+            dt = datetime.fromtimestamp(ts/1000, china_tz)
+            return dt.strftime('%Y-%m-%d')
+        
+        # 按日期和时间戳整理已有的备份
+        date_archives = {}
+        for archive in existing_archives:
+            ts = extract_timestamp(archive)
+            if ts == 0:
+                continue
+            date = get_date_from_timestamp(ts)
+            if date not in date_archives:
+                date_archives[date] = []
+            date_archives[date].append((archive, ts))
+        
+        files_to_cleanup = []
+        
+        # 对于每个日期，只保留最新的备份
+        for date, archives in date_archives.items():
+            if len(archives) > 1:
+                # 按时间戳排序（从小到大）
+                archives.sort(key=lambda x: x[1])
+                # 删除同一天的旧备份，只保留最新的
+                for archive, _ in archives[:-1]:
+                    oldest_filename = os.path.basename(archive)
+                    try:
+                        # 删除本地文件
+                        os.remove(archive)
+                        print(f"删除同一天的旧备份：{oldest_filename}")
+                        
+                        # 记录需要清理的文件名
+                        files_to_cleanup.append(oldest_filename)
+                        
+                        # 删除Hugging Face LFS文件记录
+                        print(f"正在删除Hugging Face LFS文件记录: {oldest_filename}")
+                        delete_huggingface_lfs_file(oldest_filename, f"{HF_USER1}/{HF_REPO}", HF_TOKEN1)
+                    except Exception as e:
+                        print(f"删除失败 {archive}: {e}")
+        
+        # 更新日期存档字典（只包含每天最新的备份）
+        for date in date_archives:
+            if date_archives[date]:
+                date_archives[date] = [date_archives[date][-1]]
+        
+        # 保持最近三天的备份，删除更早的
+        sorted_dates = sorted(date_archives.keys(), reverse=True)
+        if len(sorted_dates) > keep_count:
+            for old_date in sorted_dates[keep_count:]:
+                for archive, _ in date_archives[old_date]:
+                    oldest_filename = os.path.basename(archive)
+                    try:
+                        # 删除本地文件
+                        os.remove(archive)
+                        print(f"删除超过{keep_count}天的旧备份：{oldest_filename}")
+                        
+                        # 记录需要清理的文件名
+                        files_to_cleanup.append(oldest_filename)
+                        
+                        # 删除Hugging Face LFS文件记录
+                        print(f"正在删除Hugging Face LFS文件记录: {oldest_filename}")
+                        delete_huggingface_lfs_file(oldest_filename, f"{HF_USER1}/{HF_REPO}", HF_TOKEN1)
+                    except Exception as e:
+                        print(f"删除失败 {archive}: {e}")
+        
+        # 如果有文件需要从Git历史中清理，执行安全清理
+        if files_to_cleanup:
+            print(f"执行安全Git清理: {files_to_cleanup}")
+            safe_git_cleanup(output_dir, files_to_cleanup)
+        
+        # tar.gz 压缩
+        result = subprocess.run(
+            ['tar', '-czf', output_path, folder_path], 
+            capture_output=True, 
+            text=True
+        )
+        
+        if result.returncode == 0:
+            # 计算压缩包大小
+            file_size = os.path.getsize(output_path) / 1024 / 1024
+            
+            # 格式化中国时区的时间
+            china_time = datetime.now(china_tz)
+            formatted_time = china_time.strftime('%Y-%m-%d %H:%M:%S')
+            
+            print(f"压缩成功：{output_path}")
+            print(f"压缩大小：{file_size:.2f} MB")
+            print(f"压缩时间：{formatted_time}")
+            print(f"保留策略：每天一个，最多保留 {keep_count} 天备份")
+            
+            # 如果有当天的旧备份，删除
+            if current_date in date_archives and date_archives[current_date]:
+                for old_archive_info in date_archives[current_date]:
+                    old_archive, old_ts = old_archive_info
+                    old_filename = os.path.basename(old_archive)
+                    if os.path.exists(old_archive) and old_filename != os.path.basename(output_path):
+                        try:
+                            os.remove(old_archive)
+                            print(f"删除当天的旧备份：{old_filename}")
+                            delete_huggingface_lfs_file(old_filename, f"{HF_USER1}/{HF_REPO}", HF_TOKEN1)
+                            files_to_cleanup.append(old_filename)
+                        except Exception as e:
+                            print(f"删除当天旧备份失败 {old_archive}: {e}")
+            
+            # 返回压缩包名和大小信息
+            return f"{os.path.basename(output_path)} MB：{file_size:.2f} MB TIME：{formatted_time}"
+        else:
+            print("压缩失败")
+            print("错误信息:", result.stderr)
+            return None
+    
+    except Exception as e:
+        print(f"压缩出错: {e}")
+        return None
+
+
+def github(type):
+    if type == 1:
+        os.system(f'rm -rf /data/{HF_REPO} /data/ff /data/data') 
+    if not os.path.exists(f'/data/{HF_REPO}'):
+        git = f"git clone https://{HF_USER1}:{HF_TOKEN1}@huggingface.co/{HF_USER1}/{HF_REPO}"
+        print(git)
+        os.system(git)
+        os.system(f'git config --global user.email "{HF_EMAIL}"')
+        os.system(f'git config --global user.name "{HF_USER1}"') 
+        os.system("ls")
+        latest_package = get_latest_local_package(f'/data/{HF_REPO}')
+        print(f"最新压缩包路径: {latest_package}")
+        if latest_package:
+            os.system(f"tar -xzf {latest_package} -C /data")
+            os.system("mv /data/f/ff /data/")
+            os.system("mv /data/data/f/ff /data/")
+            os.system("rm -rf /data/data /data/f")
+            threading.Thread(target=repeat_task, daemon=True).start()
+    
+    if type == 2:
+        print(f"开始备份上传HF仓库：{HF_REPO}")
+        os.system("mkdir -p /data/f")
+        os.system("cp -rf /data/ff /data/f")
+        
+        # 检查本地仓库是否为空
+        if not os.path.exists("/data/f/ff") or not os.listdir("/data/f/ff"):
+            print("本地仓库为空，跳过备份上传")
+            telegram_message(BOT_TOKEN, CHAT_ID, f"Warning: {HF_ID} backup repository {HF_REPO} is empty, skipping backup upload")
+            return
+            
+        repo_path = f'/data/{HF_REPO}'
+        repo_id = f"{HF_USER1}/{HF_REPO}"
+        
+        # 切换到仓库目录
+        os.chdir(repo_path)
+        os.system(f'git config --global user.email "{HF_EMAIL}"')
+        os.system(f'git config --global user.name "{HF_USER1}"') 
+        
+        # 先清理孤儿LFS引用
+        cleanup_orphaned_lfs_references(repo_path, repo_id, HF_TOKEN1, keep_count=3)
+        
+        # 执行Git清理（不影响现有文件）
+        os.system('git lfs prune')
+        os.system('git gc --auto')
+        
+        # 备份上���仓库
+        new_archive_info = compress_folder('/data/f', repo_path, keep_count=3)
+        if new_archive_info:
+            new_archive, file_size_info = new_archive_info.split(' MB：')
+            
+            os.system("pwd")
+            os.system(f'git add .')
+            os.system(f'git commit -m "{file_size_info}"')
+            
+            # 正常推送（不再需要强制推送）
+            push_result = os.system('git push origin main')
+            if push_result != 0:
+                print("推送失败，可能有冲突，尝试拉取并合并...")
+                os.system('git pull origin main --rebase')
+                os.system('git push origin main')
+            
+            # 轻度清理
+            os.system('git gc --auto')
+            os.system('git lfs prune')
+            # telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}提交仓库{HF_REPO}结果：{file_size_info}")
+            telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID} pushed repository {HF_REPO} result: {file_size_info}")
+
+        else:
+            telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID} pushed repository {HF_REPO} result: compression failed, unable to submit")
+            # telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}提交仓库{HF_REPO}结果：压缩失败，无法提交")
+            print("压缩失败，无法提交")
+
+
+def _reconstruct_token(partial_token):
+    return partial_token.replace(" ", "")
+
+def restart_huggingface_space(space_name, space_id, partial_token):
+    token = _reconstruct_token(partial_token)
+    url = f"https://huggingface.co/api/spaces/{space_name}/{space_id}/restart?factory=true"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {token}",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
+    }
+    try:
+        response = requests.post(url, headers=headers, json={})
+        return {
+            "status_code": response.status_code,
+            "success": response.status_code == 200,
+            "message": response.text
+        }
+    except requests.RequestException as e:
+        return {
+            "status_code": None,
+            "success": False,
+            "message": str(e)
+        }
+
+
+def check_system_resources():
+    time.sleep(120)
+    cpu_usage = psutil.cpu_percent(interval=1)
+    memory = psutil.virtual_memory()
+    memory_usage = memory.percent
+    if cpu_usage >= 90 or memory_usage >= 95:
+        print("占用过高")
+        telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}CUP 内存占用过高，开始重启")
+        response = create_space(1)
+        full_name = response["name"]
+        tmp_name = full_name.split("/")[-1]
+        # log = f"“原始创建Space返回：{response} name字段:{full_name} Space 名称{tmp_name}"
+        log = f"Original create Space response: {response} | name field: {full_name} | Space name: {tmp_name}"
+        telegram_message(BOT_TOKEN, CHAT_ID, log)
+        print(log)
+        create_space(3,"BACKUP_TIME",BACKUP_TIME,tmp_name)
+        create_space(3,"HF_USER1",HF_USER1,tmp_name)
+        create_space(3,"HF_REPO",HF_REPO,tmp_name)
+        create_space(3,"HF_EMAIL",HF_EMAIL,tmp_name)
+        create_space(3,"HF_TOKEN1",HF_TOKEN1,tmp_name)
+        create_space(3,"HF_USER2",HF_USER2,tmp_name)
+        create_space(3,"HF_EMAIL2",HF_EMAIL2,tmp_name)
+        create_space(3,"HF_ID",tmp_name,tmp_name)
+        create_space(3,"HF_TOKON2",HF_TOKON2,tmp_name)
+        create_space(3,"UUID",UUID,tmp_name)
+        create_space(3,"N_SERVER","z.282820.xyz:443",tmp_name)
+        create_space(3,"CHAT_ID",CHAT_ID,tmp_name)
+        create_space(3,"BOT_TOKEN",BOT_TOKEN,tmp_name)
+        create_space(3,"HF_SPACES_NAME",HF_ID,tmp_name)
+        time.sleep(2)
+        result = restart_huggingface_space(HF_USER2, tmp_name, HF_TOKON2)
+        print(f"{tmp_name}重启结果：",result)
+        # create_space(4,"","",CHAT_ID)
+        # result = restart_huggingface_space(HF_USER2, HF_ID, HF_TOKON2)
+        # print(result)
+    else:
+        print("系统资源正常")
+
+
+def repeat_task():
+    print('备份线程启动aa')
+    while True:
+        print(f"打包时间：{BACKUP_TIME} 秒")
+        time.sleep(int(BACKUP_TIME))
+        github(2)
+# telegram_message(BOT_TOKEN, CHAT_ID, "开始")
+github(1)
+
+if os.path.exists('/data/ff/.mozilla/firefox/profiles.ini') and os.path.isfile('/data/ff/.mozilla/firefox/profiles.ini'):
+    # threading.Thread(target=repeat_task, daemon=True).start()
+    # telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID}开始启动")
+    while True:
+        print("检测到Firefox配置，启动定期重启循环...")
+        create_space(5,"","",HF_SPACES_NAME)
+        time.sleep(14400)#21600 = 6小时 14400 = 4小时
+        github(2)
+        response = create_space(1)
+        url = response["url"]
+        full_name = response["name"]
+        tmp_name = full_name.split("/")[-1]
+        # log = f"“原始创建Space返回：{response} name字段:{full_name} Space 名称{tmp_name}"
+        log = f"Original create Space response: {url} | name field: {full_name} | Space name: {tmp_name}"
+        telegram_message(BOT_TOKEN, CHAT_ID, log)
+        print(log)
+        create_space(3,"BACKUP_TIME",BACKUP_TIME,tmp_name)
+        create_space(3,"HF_USER1",HF_USER1,tmp_name)
+        create_space(3,"HF_REPO",HF_REPO,tmp_name)
+        create_space(3,"HF_EMAIL",HF_EMAIL,tmp_name)
+        create_space(3,"HF_TOKEN1",HF_TOKEN1,tmp_name)
+        create_space(3,"HF_USER2",HF_USER2,tmp_name)
+        create_space(3,"HF_EMAIL2",HF_EMAIL2,tmp_name)
+        create_space(3,"HF_ID",tmp_name,tmp_name)
+        create_space(3,"HF_TOKON2",HF_TOKON2,tmp_name)
+        create_space(3,"UUID",UUID,tmp_name)
+        create_space(3,"N_SERVER","z.282820.xyz:443",tmp_name)
+        create_space(3,"CHAT_ID",CHAT_ID,tmp_name)
+        create_space(3,"BOT_TOKEN",BOT_TOKEN,tmp_name)
+        create_space(3,"HF_SPACES_NAME",HF_ID,tmp_name)
+        time.sleep(2)
+        create_space(4,"","",tmp_name)
+        time.sleep(2)
+        result = restart_huggingface_space(HF_USER2, tmp_name, HF_TOKON2)
+        print(f"{tmp_name}重启结果：",result)
+        telegram_message(BOT_TOKEN, CHAT_ID, f"{HF_ID} startup finished")
+        # create_space(4,"","",CHAT_ID)
+        # result = restart_huggingface_space(HF_USER2, HF_ID, HF_TOKON2)
+        # print(result)
+        break
+# github(2)
+# nv1_agent()