Update server5.py

server5.py

@@ -104,136 +104,55 @@ os.system("chmod +x /content/frp/frpc")
 
 # 更新软件包列表
 def is_installed(package):
-    """Check if a package is installed."""
+    """检查软件包是否已安装"""
     try:
-        # Check if the package is installed using dpkg (for apt packages)
         subprocess.run(['dpkg', '-s', package], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         return True
-    except Exception as e:
+    except Exception:
         return False
 
 def install_package(package):
-    """Install a package using apt."""
-    print(f"Installing {package}...")
-    os.system(f"sudo apt install {package} -y  > /dev/null 2>&1")
+    """使用apt安装软件包"""
+    print(f"正在安装 {package}...")
+    os.system(f"sudo apt install {package} -y > /dev/null 2>&1")
+
 def update():
     print('-----------更新软件包列表开始-------------')
-    # os.system("sudo apt update")
-    # 安装 Node.js 和 npm
-    # os.system("sudo apt install nodejs npm -y")
-    # # 全局安装 forever
-    # os.system("sudo npm install -g forever")
-    if not is_installed('nodejs'):
-        install_package('nodejs')
     
-    if not is_installed('npm'):
-        install_package('npm')
-    os.system("pip install -U kaggle > /dev/null 2>&1")   
-    os.system("pip uninstall -y kaggle > /dev/null 2>&1")    
-    os.system("pip install kaggle==1.5.6 > /dev/null 2>&1")
-    # os.system("apt-get install inotify-tools > /dev/null 2>&1")
-    os.system("pip install ruamel.yaml > /dev/null 2>&1")  # install ruamel.yaml to solve the import issue
-    os.system("pip install pexpect > /dev/null 2>&1")
-    os.system("pip install pytz > /dev/null 2>&1")
-    os.system('pip install paramiko > /dev/null 2>&1')
-    os.system('apt-get install pigz -y > /dev/null 2>&1')
-    os.system('apt-get install pv -y > /dev/null 2>&1')
-    os.system("sudo apt install p7zip-full -y > /dev/null 2>&1")
-
-    print('-----------更新软件包列表结束-------------')
-update()
-
-
-from ruamel.yaml import YAML
-clear_output(wait=True)  # 清除输出
-
-def kill_frpc_processes():
-    try:
-        # 使用pkill命令结束所有frpc进程
-        subprocess.run(['pkill', '-f', 'frpc'], check=True)
-        print("所有frpc进程已被结束。")
-    except subprocess.CalledProcessError as e:
-        # 如果pkill命令失败，打印错误信息
-        print(f"结束frpc进程时出错: {e}")
-kill_frpc_processes()
-
-
-# Oneapi中转
-def Oneapi():
-    print('-----------Oneapi中转开始-------------')
-    # 删除旧的 one-api 文件夹（如果存在）
-    os.system("rm -rf /one/one-api")  # 使用 -f 参数以避免错误
-    os.system("mkdir -p /one")  # 创建目录
-    # 下载 one-api 文件
-    url = "https://github.com/songquanpeng/one-api/releases/download/v0.6.8/one-api"
-    os.system(f"wget {url} -O /one/one-api")  # 正确下载并重命名为 /one/one-api
-    # 修改文件权限，使其可执行
-    os.system("chmod +x /one/one-api")
-    # 设置环境变量
-    os.environ["THEME"] = "berry"
-    os.environ["TIKTOKEN_CACHE_DIR"] = os.getcwd()  # 使用Python的os.getcwd()获取当前工作目录
-    # 设置MySQL数据库的环境变量
-    db_user = "oneapi"
-    db_password = "epBjK5ZKysCe6yr3"
-    db_host = "106.52.51.116"
-    db_port = "3306"
-    db_name = "oneapi"
-    dsn = f"{db_user}:{db_password}@tcp({db_host}:{db_port})/{db_name}"
-    os.environ["SQL_DSN"] = dsn
-    command = ['/one/one-api', '--port', '3000']
-    process = subprocess.Popen(command)  # 启动程序并将其放到后台执行
-    print(f"OneAPI程序已在后台启动，进程ID为：{process.pid}")
-    print('-----------Oneapi中转结束-------------')
-# Oneapi()
-
-# SSH
-def run_command(command):
-    try:
-        subprocess.run(command, check=True, shell=True)
-    except subprocess.CalledProcessError as e:
-        print(f"An error occurred: {e}")
-def ssh():
-    print('-----------SSH开始-------------')
-    subprocess.run("apt update", check=True, shell=True)
-    subprocess.run("apt install openssh-server -y", check=True, shell=True)
-    subprocess.run("apt-get install vim -y", check=True, shell=True)
+    # 安装必要的软件包
+    packages = {
+        'nodejs': '安装Node.js',
+        'npm': '安装npm',
+        'p7zip-full': '安装7zip',
+        'pigz': '安装pigz压缩工具',
+        'pv': '安装pv工具',
+        'openssh-server': '安装SSH服务器'
+    }
     
-    config_client_cmd = "sudo sed -i '/PasswordAuthentication/s/^#//g' /etc/ssh/ssh_config"
-    subprocess.run(config_client_cmd, check=True, shell=True)
-    config_server_cmd = "sudo sed -i '/PermitRootLogin prohibit-password/s/prohibit-password/yes/' /etc/ssh/sshd_config"
-    subprocess.run(config_server_cmd, check=True, shell=True)
-    run_command("systemctl restart ssh")
-
-    os.system("/etc/init.d/ssh restart")
-    os.system("echo 'root:qilan' | sudo chpasswd")
-    os.system("echo 'PermitRootLogin yes' | sudo tee -a /etc/ssh/sshd_config")
-    os.system("service ssh restart ")
-    os.system("export LD_LIBRARY_PATH=$(echo $LD_LIBRARY_PATH | tr ':' '\n' | grep -v '/opt/conda/lib' | paste -sd ':') ")
-    print('-----------SSH结束-------------')
-ssh()
-clear_output()
-
-import json
-import os
-import subprocess
-import threading
-import time
-
-# 创建一个锁
-lock = threading.Lock()
-# data_folder = '/sillytavern/*'
-# zip_file_path = '/a/sillytavern.zip'
-data_folder = '/root/SillyTavern'  # 要压缩的目录
-zip_file_path = '/a/sillytavern.tar.gz'  # 输出的 tar.gz 文件路径
-metadata_file_path = '/a/dataset-metadata.json'
-last_uploaded_size = -1
+    for package, description in packages.items():
+        if not is_installed(package):
+            print(description)
+            install_package(package)
+    
+    # 安装Python包
+    python_packages = [
+        'kaggle==1.5.6',
+        'ruamel.yaml',
+        'pexpect',
+        'pytz',
+        'paramiko'
+    ]
+    
+    for package in python_packages:
+        os.system(f"pip install {package} > /dev/null 2>&1")
+    
+    print('-----------更新软件包列表结束-------------')
 
-def update_last_uploaded_size(size):
-    global last_uploaded_size
-    last_uploaded_size = size
+# ... 其他函数保持不变 ...
 
 def compress_folder():
-    global last_uploaded_size  # 声明使用全局变量
+    """压缩SillyTavern文件夹并上传到Kaggle"""
+    global last_uploaded_size
 
     # 清理并创建目录 /a
     if os.path.exists('/a'):
@@ -241,372 +160,109 @@ def compress_folder():
 
     os.makedirs('/a', exist_ok=True)
 
-    with lock:  # 使用锁
+    with lock:
         if os.path.exists(zip_file_path):
             print(f"压缩文件 {zip_file_path} 已存在，跳过本次压缩。")
             return
         
         print('开始压缩数据')
-        #result = subprocess.run(['7z', 'a', '-tzip', '-mx=1','-mmt=2', zip_file_path, data_folder])
-        # 7z a -tzip -mx=1 -mmt=2 /a/sillytavern.zip /sillytavern/*
-        # tar -cvf - /sillytavern | pigz -p 6 -1 > /a/sillytavern.tar.gz
         try:
+            # 使用pigz进行多线程压缩，提高效率
             result = subprocess.run(
-            f'tar -cvf - {data_folder} | pigz -p 2 -1 > {zip_file_path} 2> /dev/null',
-            shell=True,
-            check=True,
-            stdout=subprocess.DEVNULL,  # 将标准输出重定向到 /dev/null
-            stderr=subprocess.DEVNULL   # 将标准错误也重定向到 /dev/null
+                f'tar -cf - {data_folder} | pigz -p 4 -1 > {zip_file_path} 2> /dev/null',
+                shell=True,
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL
             )
+            print('压缩完成')
         except subprocess.CalledProcessError as e:
-            print(f"Command failed with return code {e.returncode}")
+            print(f"压缩命令失败，返回码: {e.returncode}")
+            return
 
         print('重命名压缩后的文件')
         file_path = "/a/sillytavern.ctk"
-        print(zip_file_path)
-        
-        subprocess.run(['mv', zip_file_path,file_path])
-        if result.returncode != 0:
-            print("压缩失败，请检查7z命令是否正确")
-            return
+        subprocess.run(['mv', zip_file_path, file_path])
 
-        print(f"Data compressed into {file_path}")
+        print(f"数据已压缩到 {file_path}")
         
-        file_size = os.path.getsize(file_path)  # 获取压缩包的大小
-        print('文件大小:', file_size, '上次文件大小：', last_uploaded_size,file_size * 1024 ** 2)
+        file_size = os.path.getsize(file_path)
+        print(f'文件大小: {file_size/1024/1024:.2f}MB, 上次文件大小: {last_uploaded_size/1024/1024:.2f}MB 如果上次为-1')
         
-        # 判断是否大于800MB (800MB = 800 * 1024 * 1024 字节)
-        if file_size < (400 * 1024 ** 2):  
-            print("文件小于800MB，不进行上传。")
+        # 判断是否大于400MB
+        if file_size < (400 * 1024 * 1024):  
+            print("文件小于400MB，不进行上传。")
             return
         
-        if last_uploaded_size == -1 or file_size != last_uploaded_size:
-            # 判断是否为首次运行或上次上传大小为0
-            if last_uploaded_size == -1:
-                print("首次运行，正在执行上传...")
-                update_last_uploaded_size(file_size)  # 更新为当前文件大小
-
-                with open(metadata_file_path, 'w') as json_fid:
-                    json.dump(kaggle_metadata, json_fid)
-                os.system("kaggle datasets version -m 'new version message' -p /a")
-                #subprocess.run(['kaggle', 'datasets', 'version', '-m', 'new version message', '-p', '/a'])
-                # kaggle datasets version -m 'new version message' -p /a
-                last_uploaded_size = file_size
-            
-            elif file_size > last_uploaded_size:
-                print(f"新文件 {zip_file_path} 大于上次上传的大小，正在执行上传...")
-                update_last_uploaded_size(file_size)  # 更新元数据中的最后一次上传大小
-
-                with open(metadata_file_path, 'w') as json_fid:
-                    json.dump(kaggle_metadata, json_fid)
-
-                subprocess.run(['kaggle', 'datasets', 'version', '-m', 'new version message', '-p', '/a'])
-                last_uploaded_size = file_size
-            
-        else:
-            print(f"新文件 {zip_file_path} 不大于上次上传的大小，跳过")
-
-
-def repeat_task():
-    print('------打包线程启动-------------')
-    while True:
-        print('等待打包')
-        time.sleep(18000)
-        compress_folder()
-    print('------打包线程结束-------------')
-
-
-import os
-import subprocess
-import pexpect
-
-def generate_ssh_key():
-    # 生成 SSH 密钥对，并捕获输出和错误信息
-    os.system("rm -f ~/.ssh/id_rsa ~/.ssh/id_rsa.pub")
-    keygen_command = "ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa -N ''"
-    try:
-        result = subprocess.run(keygen_command, shell=True, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        print("SSH key pair generated.")
-        print(result.stdout.decode())   # 打印标准输出信息（如成功消息）
-    except subprocess.CalledProcessError as e:
-        print(f"Failed to generate SSH key: {e.stderr.decode() if e.stderr else e}")
-
-def copy_public_key_to_remote(host, port, user, password):
-    # 使用 pexpect 自动输入密码来复制公钥
-    try:
-        command = f"ssh-copy-id -o StrictHostKeyChecking=no -p {port} {user}@{host}"
-        child = pexpect.spawn(command)
-
-        # 等待密码提示并发送密码
-        child.expect("password:", timeout=10)  # 增加超时时间
-        child.sendline(password)
-
-        # 等待命令完成并输出结果
-        child.expect(pexpect.EOF)
+        # 上传逻辑优化
+        should_upload = (last_uploaded_size == -1) or (file_size > last_uploaded_size * 1.05)
         
-        print(child.before.decode())  # 打印输出结果
-        
-    except Exception as e:
-        print(f"An error occurred: {e}")
-
+        if should_upload:
+            print(f"{'首次上传' if last_uploaded_size == -1 else '文件大小显著增加'}，正在执行上传...")
+            update_last_uploaded_size(file_size)
+
+            with open(metadata_file_path, 'w') as json_fid:
+                json.dump(kaggle_metadata, json_fid)
+                
+            try:
+                upload_result = subprocess.run(
+                    ['kaggle', 'datasets', 'version', '-m', 'new version message', '-p', '/a'],
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE
+                )
+                print("上传成功:", upload_result.stdout.decode())
+            except subprocess.CalledProcessError as e:
+                print(f"上传失败: {e.stderr.decode() if e.stderr else e}")
+        else:
+            print(f"新文件大小变化不显著，跳过上传")
 
-# 生成 SSH 密钥对
-generate_ssh_key()
-os.system('chmod 600 ~/.ssh/id_rsa')
-# # 复制公钥到远程服务器
-copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
- 
-def write_rsyncd_conf(path, port=7071):
-    rsyncd_conf_content = f"""
-port = {port}
-[qilan]
-    path = {path}
-    comment = My rsync module
-    read only = no
-    list = yes
-"""
-    with open('/etc/rsyncd.conf', 'w') as f:
-        f.write(rsyncd_conf_content.strip())
-    print(f"Successfully wrote to /etc/rsyncd.conf for module .")
+# 改进SSH密钥管理
+def setup_ssh():
+    """设置SSH服务和密钥"""
+    print('-----------SSH配置开始-------------')
     
-write_rsyncd_conf(data_folder)
-os.system("sudo rsync --daemon")
-os.system("ps aux | grep rsync")
-
-def requests_retry_session(retries=3, backoff_factor=0.3, status_forcelist=(500, 502, 504), session=None):
-    """创建一个带重试机制的请求会话"""
-    session = session or requests.Session()
-    retry = Retry(total=retries, backoff_factor=backoff_factor, status_forcelist=status_forcelist)
-    adapter = HTTPAdapter(max_retries=retry)
-    session.mount('http://', adapter)
-    session.mount('https://', adapter)
-    return session
-
-import os
-import time
-import requests
-import subprocess
-import logging
-
-import paramiko
-
-def check_ssh_connection(host, port, username, password):
-    try:
-        client = paramiko.SSHClient()
-        # 允许连接到不在 known_hosts 中的主机
-        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        # 尝试连接
-        client.connect(hostname=host, port=port, username=username, password=password)
-        client.close()
-        return True
-    except Exception as e:
-        print(f"SSH 连接失败: {e}")
-        return False
-
-
-
-
-# 配置日志
-logging.basicConfig(level=logging.INFO)
-
-def check_api1():
-    # 第一次检查 SillyTavern 是否启动
-    thread_started = False
-    n = 0
-    while True:
-        n += 1
-        if not os.path.exists(data_folder):
-            logging.error(f"/sillytavern/ 文件不存在，结束检测")
-            break
-        try:
-            url = "http://127.0.0.1:8000/v1"
-            response = requests.get(url, timeout=30)
-
-            if response.status_code == 403:
-                print("SillyTavern已经启动")
-                break
-            
-            print("SillyTavern未启动，状态码:", response.status_code, n)
-
-        except requests.exceptions.RequestException as e:
-            print(f"SillyTavern未启动3: {e}, 尝试次数: {n}")
-        
-        time.sleep(5)
+    # 安装和配置SSH服务器
+    subprocess.run("apt update", check=True, shell=True)
+    subprocess.run("apt install openssh-server -y", check=True, shell=True)
     
-    print('ST本地已经运行，开始检测接口状态')
-    Service_status = False
-    n = 0
-    nn = 0
-    while True:
-        n += 1
-        if not os.path.exists(data_folder):
-            print(f"/sillytavern/ 文件不存在，结束检测")
-            break
-        if Service_status:
-            print("结束检测")
-            break
-        if nn > 2:
-            break
-        url = f"{st_url}/csrf-token"
+    # 配置SSH允许root登录
+    config_commands = [
+        "sudo sed -i '/PasswordAuthentication/s/^#//g' /etc/ssh/ssh_config",
+        "sudo sed -i '/PermitRootLogin prohibit-password/s/prohibit-password/yes/' /etc/ssh/sshd_config",
+        "echo 'PermitRootLogin yes' | sudo tee -a /etc/ssh/sshd_config",
+        "echo 'root:qilan' | sudo chpasswd",
+        "systemctl restart ssh",
+        "/etc/init.d/ssh restart",
+        "service ssh restart"
+    ]
+    
+    for cmd in config_commands:
         try:
-            response = requests_retry_session().get(url, timeout=30)
-            response.raise_for_status()
-            response_json = response.json()
-            print("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
-            if "token" in response_json:
-                print("检测到 token")
-                try:  
-                    subprocess.run(f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",shell=True, check=True)
-                    # break  # 如果成功，跳出重试循环
-                except subprocess.CalledProcessError as e:
-                    nn += 1
-                    print(f"Rsync 失败，返回码: {e.returncode}, 尝试次数: {nn}")
-                    generate_ssh_key()  # 处理 SSH 密钥生成
-            else:
-                print("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
-        except requests.exceptions.ConnectionError as e:
-            print(f"接口异常1: {e}, 尝试次数: {n}, nn: {nn}")
-            # time.sleep(3)
-            nn += 1
-            if nn > 5:
-                break
-        except requests.exceptions.Timeout as e:
-            print(f"接口异常2: {e}, 尝试次数: {n}")
-            break
-        except requests.exceptions.RequestException as e:
-            print(f"接口异常3: {e}, 尝试次数: {n}")
-            break
-        
-        time.sleep(5)
-
-
-def frp(configs, backstage):
-     print('-----------FRP开始-------------')
-     # 遍历所有配置并启动 FRP。
-     for config_data, config_file_path in configs:
-         with open(config_file_path, 'w') as config_file:
-             config_file.write(config_data)
-         
-         # 启动 frpc 命令和参数。
-         frpc_cmd=['/content/frp/frpc', '-c', config_file_path]
-
-         if backstage:
-             subprocess.Popen(frpc_cmd)
-         else:
-             subprocess.run(f'/content/frp/frpc -c {config_file_path}', shell=True, check=True)
-
-     print('-----------FRP结束-------------')
-   
-import requests
-import re
-from datetime import datetime, timedelta
-import psutil  # 用于获取系统启动时间
-import pytz  # 用于处理时区
-
-def get_current_ip():
-    """获取当前公共 IP 地址"""
-    response = requests.get("https://ipinfo.io/ip")
-    return response.text.strip()
-
-def get_geo_info(ip_address):
-    """根据 IP 地址获取地理位置信息"""
-    url = f"https://api.qjqq.cn/api/Local"
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
-    }
+            subprocess.run(cmd, shell=True, check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"SSH配置命令失败: {cmd}, 错误: {e}")
     
-    response = requests.get(url, headers=headers)
+    # 生成SSH密钥
+    generate_ssh_key()
+    os.system('chmod 600 ~/.ssh/id_rsa')
     
-    if response.status_code == 200:
-        geo_info = response.json()
-        
-        if geo_info['code'] == 200:
-            data = geo_info['data']
-            return {
-                'ip': data['ip'],
-                'country': data['country'],
-                'isp': data['isp']
-            }
-    return None
-
-def get_next_relay_time():
-    """获取下一次接力时间（系统启动时间+12小时，转换为中国时区）"""
-    # 获取系统启动时间
-    boot_time = datetime.fromtimestamp(psutil.boot_time())
-    # 设置为UTC时区
-    utc = pytz.UTC
-    boot_time = utc.localize(boot_time)
-    # 转换为中国时区
-    china_tz = pytz.timezone('Asia/Shanghai')
-    boot_time_china = boot_time.astimezone(china_tz)
-    # 加上12小时
-    next_time = boot_time_china + timedelta(hours=12)
-    return next_time.strftime("%Y-%m-%d %H:%M:%S")
-
-def replace_info_in_file(file_path):
-    try:
-        # 获取当前 IP 地址和地理信息
-        ip_address = get_current_ip()
-        geo_info = get_geo_info(ip_address)
-        next_relay_time = get_next_relay_time()
-        
-        if geo_info is not None:
-            # 读取文件内容
-            with open(file_path, 'r', encoding='utf-8') as file:
-                content = file.read()
-            
-            # 替换接力时间
-            time_pattern = r'接力时间\[.*?\]'
-            time_replacement = f'接力时间[{next_relay_time}]'
-            content = re.sub(time_pattern, time_replacement, content)
-            
-            # 替换 IP 信息
-            ip_pattern = r'IP\[.*?\]\s*国家\s*\[.*?\]\s*IPS\[.*?\]'
-            ip_replacement = f'IP[{ip_address}] 国家 [{geo_info["country"]}] IPS[{geo_info["isp"]}]'
-            content = re.sub(ip_pattern, ip_replacement, content)
-            
-            # 写回文件
-            with open(file_path, 'w', encoding='utf-8') as file:
-                file.write(content)
-            
-            print(f"成功更新信息：")
-            print(f"接力时间: {next_relay_time}")
-            print(f"IP信息: IP[{ip_address}] 国家 [{geo_info['country']}] IPS[{geo_info['isp']}]")
+    # 尝试复制公钥到远程服务器
+    max_attempts = 3
+    for attempt in range(max_attempts):
+        try:
+            copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
+            print(f"SSH密钥复制成功 (尝试 {attempt+1}/{max_attempts})")
+            break
+        except Exception as e:
+            print(f"SSH密钥复制失败 (尝试 {attempt+1}/{max_attempts}): {e}")
+            if attempt < max_attempts - 1:
+                print("5秒后重试...")
+                time.sleep(5)
     
-    except Exception as e:
-        print(f"发生错误: {e}")
-
-import socket
-import subprocess
-import time
+    print('-----------SSH配置结束-------------')
 
-def monitor_port():
-    while True:
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-            result = sock.connect_ex(('localhost', 8000))
-            if result == 0:
-                print(f"端口 8000 正在使用中")
-            else:
-                print(f"端口 8000 未被使用")
-                backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
-                backup_thread.start()
-        time.sleep(5)  # 每5秒检查一次
-def Run_SillyTavern():
-    
-    # subprocess.run(f'node "server.js" "$@"', shell=True, check=True)
-    try:
-        os.chdir(data_folder)
-        # 启动 Node.js 服务器，并将输出重定向到 /dev/null
-        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-        subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
-        print("已尝试启动 server.js")
-    except subprocess.CalledProcessError as e:
-        print(f"Run_SillyTavern命令失败，返回码: {e.returncode}")
-    except Exception as e:  # 捕获所有其他异常
-        print(f"Run_SillyTavern发生异常: {e}")
+# 改进SillyTavern下载和安装
 def SillyTavern():
     print('-----------SillyTavern开始-------------')
     # 创建目录并写入 kaggle.json
@@ -618,96 +274,131 @@ def SillyTavern():
 
     clear_output()
 
-    os.system(f"rm -r /a /sillytavern /*.zi* {data_folder}")
+    # 清理旧文件并创建目录
+    os.system(f"rm -rf /a /sillytavern /*.zi* {data_folder}")
     os.system(f"mkdir -p {data_folder}")
     os.chdir('/')
-    print(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name}")
-    # os.system(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name}")
-    download_n = 0
-    while True:
-        # 执行下载命令
-        if download_n > 6:
-            break
+    
+    # 下载数据集，带重试机制
+    print(f"正在下载数据集: {huggingface_name}/{huggingface_Data_name}")
+    download_success = False
+    max_attempts = 6
+    
+    for attempt in range(max_attempts):
+        print(f"下载尝试 {attempt+1}/{max_attempts}")
         os.system(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /")
-        # 检查文件是否存在
+        
         if os.path.exists(f'/{huggingface_Data_name}.zip'):
-            print(f"{huggingface_Data_name}.zip 下载成功！")
-            break  # 跳出循环
-        print(f"{huggingface_Data_name}.zip 下载失败，正在重试...")
-        download_n += 1
-        time.sleep(300)  # 等待一段时间再重试（例如5秒
-    # os.system('kaggle datasets download xovale7506/sillytavern-data2')
-    # 检查文件是否存在
-    if not os.path.exists(f'/{huggingface_Data_name}.zip'):
-        print(f"文件 /{huggingface_Data_name}.zip 不存在，启用实时同步。")
-        generate_ssh_key()
-        copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
-        subprocess.run(f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",shell=True, check=True)
-        # subprocess.run(f"rsync -avz --port=7075 ljj@{frp_url}::qilan {data_folder}/", shell=True, check=True)
-        # sys.exit()
+            file_size = os.path.getsize(f'/{huggingface_Data_name}.zip')
+            print(f"{huggingface_Data_name}.zip 下载成功！文件大小: {file_size/1024/1024:.2f}MB")
+            download_success = True
+            break
+            
+        print(f"下载失败，5分钟后重试...")
+        time.sleep(300)
+    
+    # 如果下载失败，尝试使用rsync同步
+    if not download_success:
+        print(f"下载失败，尝试使用rsync从远程服务器同步")
+        try:
+            setup_ssh()  # 确保SSH配置正确
+            rsync_cmd = f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/"
+            print(f"执行同步命令: {rsync_cmd}")
+            subprocess.run(rsync_cmd, shell=True, check=True)
+            print("同步完成")
+        except subprocess.CalledProcessError as e:
+            print(f"同步失败: {e}")
     else:
-        
-        # 如果文件存在，可以继续执行后续代码
-        print(f"文件 /{huggingface_Data_name}.zip 存在，继续执行程序。")
-    # # 解压 sillytavern.zip
-        # os.system("rm *.zip")
-        os.system("ls /")
-        os.system(f"7z x /{huggingface_Data_name}.zip -o/ -y")
-        # os.system("mv /sillytavern.zip1 /sillytavern.zip")
-        # os.system("7z x /sillytavern.zip -o/sillytavern -y")
-        os.system("mv /sillytavern.tck sillytavern.tar.gz")
-        os.system("mv /sillytavern.ctk sillytavern.tar.gz")
-        # os.system("tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz")
-        os.system(f"tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz > /dev/null")
-        # os.system("pv /sillytavern.tar.gz | tar -xvpf - -C / --use-compress-program=pigz")
-
-        
+        # 解压文件
+        print("开始解压文件...")
+        try:
+            # 处理不同可能的文件名
+            if os.path.exists(f'/{huggingface_Data_name}.zip'):
+                os.system(f"7z x /{huggingface_Data_name}.zip -o/ -y > /dev/null")
+            
+            # 处理可能的文件名变体
+            for possible_file in ['/sillytavern.tck', '/sillytavern.ctk']:
+                if os.path.exists(possible_file):
+                    os.system(f"mv {possible_file} /sillytavern.tar.gz")
+            
+            # 解压tar.gz文件
+            if os.path.exists('/sillytavern.tar.gz'):
+                os.system(f"tar -xf /sillytavern.tar.gz -C / --use-compress-program=pigz > /dev/null")
+                print("解压完成")
+        except Exception as e:
+            print(f"解压过程中出错: {e}")
+    
+    # 安装和启动SillyTavern
+    if os.path.exists(f'{data_folder}'):
         os.chdir(data_folder)
-        # os.system('git merge --abort')
-        # os.system('git reset --hard')
-        # os.system('git pull --rebase --autostash')
-        print('更新文件')
-        os.system(f"ls {data_folder}")
+        print('更新SillyTavern...')
+        
+        # 安装Node.js依赖
         os.system("nvm install node")
         os.system("nvm use node")
         os.system("npm install -y")
+        
+        # 启动SillyTavern
         try:
+            print("启动SillyTavern...")
             subprocess.run(f'yes | sh {data_folder}/start.sh', shell=True, check=True)
         except subprocess.CalledProcessError as e:
-            print(f"Command '{e.cmd}' returned non-zero exit status {e.returncode}.")
-            print("Output:", e.output)
-        os.system(f"ls {data_folder}")
+            print(f"启动失败: {e}")
         
-        
-        backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
-        backup_thread.start()
-        os.system(f"rm -r /{huggingface_Data_name}.zip /sillytavern.tar.gz")
-
-    print('-----------SillyTavern结束-------------')  
-threading.Thread(target=SillyTavern, daemon=True).start()
-time.sleep(60)
-check_api1()
+        # 清理下载的文件
+        os.system(f"rm -rf /{huggingface_Data_name}.zip /sillytavern.tar.gz")
+    else:
+        print(f"错误: {data_folder}目录不存在")
 
-if os.path.exists(f'{data_folder}/start.sh'):
-    replace_info_in_file(f'{data_folder}/public/login.html')
-    # threading.Thread(target=repeat_task, daemon=True).start() #压缩备份
-    backup_thread = threading.Thread(target=repeat_task, daemon=True)
-    backup_thread.start()
-    print("开始衔接")
-    Service_status = True
-    frp(configs, True)
+    print('-----------SillyTavern结束-------------')
 
-    threading.Thread(target=monitor_port, daemon=True).start()#检测端口状态
-    while True:
-        if backup_thread.is_alive():
-            print("备份线程仍在运行...")
-        else:
-            print("备份线程已停止.")
-            backup_thread = threading.Thread(target=repeat_task, daemon=True)
-            backup_thread.start()
-            break
-        time.sleep(5)
+# 主程序逻辑优化
+def main():
+    # 初始化
+    update()
+    kill_frpc_processes()
+    setup_ssh()
+    
+    # 启动SillyTavern
+    st_thread = threading.Thread(target=SillyTavern, daemon=True)
+    st_thread.start()
+    
+    # 等待SillyTavern启动
+    print("等待SillyTavern启动...")
+    time.sleep(60)
+    check_api1()
+    
+    # 如果SillyTavern已启动，开始其他服务
+    if os.path.exists(f'{data_folder}/start.sh'):
+        # 更新登录页面信息
+        replace_info_in_file(f'{data_folder}/public/login.html')
+        
+        # 启动备份线程
+        print("启动备份线程...")
+        backup_thread = threading.Thread(target=repeat_task, daemon=True)
+        backup_thread.start()
+        
+        # 启动FRP
+        print("启动FRP服务...")
+        Service_status = True
+        frp(configs, True)
+        
+        # 启动端口监控
+        threading.Thread(target=monitor_port, daemon=True).start()
+        
+        # 监控备份线程
+        while True:
+            if backup_thread.is_alive():
+                print("备份线程运行中...")
+            else:
+                print("备份线程已停止，重新启动...")
+                backup_thread = threading.Thread(target=repeat_task, daemon=True)
+                backup_thread.start()
+            time.sleep(300)  # 每5分钟检查一次
+    else:
+        print(f"错误: {data_folder}/start.sh 不存在，无法继续执行")
+        compress_folder()
 
-else:
-    print("/sillytavern 文件不存在结束执行")
-compress_folder()
+# 如果直接运行脚本，执行main函数
+if __name__ == "__main__":
+    main()