Update server6.py

server6.py

@@ -1,8 +1,8 @@
 ini_content = {"username":"hdsg142saa","key":"2da57ac0c245c1ebba26017f161d5558"}
 frp_url = '119.8.118.149'
-ssh_port = '7078'
+ssh_port = '7079'
 ssh_url = '43.135.135.22'
-st_url = f'http://{frp_url}:7076'
+st_url = f'http://{frp_url}:7077'
 huggingface_name = 'hdsg142saa'
 huggingface_Data_name = 'qilan-st5'
 configs = [
@@ -11,64 +11,64 @@ configs = [
     server_addr = 47.237.156.222
     server_port = 7000
 
-    [safsa55]
+    [safsa666]
     type = tcp
     local_ip = 127.0.0.1
     local_port = 8000
-    remote_port = 7080
+    remote_port = 7082
     
-    [sascb2f55]
+    [sascb2f666]
     type = tcp
     local_ip = 127.0.0.1
     local_port = 22
-    remote_port = 7081
+    remote_port = 7083
     """, '/content/frp/frpc.ini'),
     (f"""
     [common]
     server_addr = {frp_url}
     server_port = 7000
     token = qilan
-    [kkjmk5]
+    [kkjmk6]
     type = tcp
     local_ip = 127.0.0.1
     local_port = 8000
     remote_port = 7076
     """, '/content/frp/frpc1.ini'),
-    ("""
-    [common]
-    server_addr = 47.237.78.158
-    server_port = 7000
-    [kjas2]
-    type = tcp
-    local_ip = 127.0.0.1
-    local_port = 8000
-    remote_port = 7075
-    """, '/content/frp/frpc2.ini'),
-   ("""
-   [common]
-   server_addr = 45.94.69.159
-   server_port = 7000
-   [kja1sh5]
-   type = tcp
-   local_ip = 127.0.0.1
-   local_port = 8000
-   remote_port = 7075
-   """, '/content/frp/frpc3.ini'),
-   ("""
-   [common]
-   server_addr = 43.128.135.88
-   server_port=7000 
-   [kkji1mk5] 
-   type=tcp 
-   local_ip=127.0.0.1
-   local_port=8000 
-   remote_port=7075
-     """, '/content/frp/frpc4.ini'),
+   #  ("""
+   #  [common]
+   #  server_addr = 47.237.78.158
+   #  server_port = 7000
+   #  [kjas2]
+   #  type = tcp
+   #  local_ip = 127.0.0.1
+   #  local_port = 8000
+   #  remote_port = 7075
+   #  """, '/content/frp/frpc2.ini'),
+   # ("""
+   # [common]
+   # server_addr = 45.94.69.159
+   # server_port = 7000
+   # [kja1sh5]
+   # type = tcp
+   # local_ip = 127.0.0.1
+   # local_port = 8000
+   # remote_port = 7075
+   # """, '/content/frp/frpc3.ini'),
+   # ("""
+   # [common]
+   # server_addr = 43.128.135.88
+   # server_port=7000 
+   # [kkji1mk5] 
+   # type=tcp 
+   # local_ip=127.0.0.1
+   # local_port=8000 
+   # remote_port=7075
+   #   """, '/content/frp/frpc4.ini'),
    (f"""
    [common]
    server_addr = {ssh_url}
    server_port=7000 
-   [kkji1mk5] 
+   [kkji1mk6] 
    type=tcp 
    local_ip=127.0.0.1
    local_port=22 
@@ -81,13 +81,9 @@ kaggle_metadata = {
     "licenses": [{"name": "CC0-1.0"}]
 }
 st_status = True
-import os
-os.system("pip install paramiko")
-# 导入必要的模块
 import subprocess
-
+import os
 import sys
-import logging
 from IPython.display import clear_output
 import urllib.request
 from pathlib import Path
@@ -96,123 +92,71 @@ import json
 import threading
 import time
 import pexpect
-import glob
-import socket
-import re
-from datetime import datetime, timedelta
-import psutil
-import pytz
-import paramiko
+import glob  # 导入 glob 模块
 from requests.adapters import HTTPAdapter
 from requests.packages.urllib3.util.retry import Retry
-from ruamel.yaml import YAML
-
-# 配置日志
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# 文件和目录设置
-data_folder = '/root/SillyTavern'  # 要压缩的目录
-zip_file_path = '/a/sillytavern.tar.gz'  # 输出的 tar.gz 文件路径
-metadata_file_path = '/a/dataset-metadata.json'
-
-# 创建锁和共享变量
-lock = threading.Lock()
-last_uploaded_size = -1
-service_status = False
-
-# 初始设置
 os.system("rm -r /sync.sh")
 os.system("wget -O /sync.sh https://huggingface.co/datasets/Qilan2/st-server/resolve/main/sync.sh")
 os.system("export LC_ALL=zh_CN.UTF-8")
 os.system("mkdir -p /content/frp")
-os.system("wget https://huggingface.co/Qilan2/box/resolve/main/frp/frpc -O /content/frp/frpc")
+os.system("wget /content/frp/frpc https://huggingface.co/Qilan2/box/resolve/main/frp/frpc -O /content/frp/frpc")
 os.system("chmod +x /content/frp/frpc")
 
 # 更新软件包列表
 def is_installed(package):
-    """检查软件包是否已安装"""
+    """Check if a package is installed."""
     try:
-        subprocess.run(['dpkg', '-s', package], 
-                      stdout=subprocess.PIPE, 
-                      stderr=subprocess.PIPE,
-                      check=True)
+        # 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 subprocess.CalledProcessError:
+    except Exception as e:
         return False
 
 def install_package(package):
-    """使用apt安装软件包"""
-    logger.info(f"正在安装 {package}...")
-    subprocess.run(
-        f"sudo apt install {package} -y > /dev/null 2>&1",
-        shell=True,
-        check=False
-    )
-
-def update_packages():
-    """更新和安装所需软件包"""
-    logger.info('��始更新软件包列表')
-    
-    # 安装必要的系统依赖
-    packages = {
-        'system': ['nodejs', 'npm', 'pigz', 'pv', 'p7zip-full', 'openssh-server', 'vim'],
-        'python': ['kaggle==1.5.6', 'ruamel.yaml', 'pexpect', 'pytz', 'paramiko']
-    }
-    
-    # 安装系统包
-    for pkg in packages['system']:
-        if not is_installed(pkg):
-            install_package(pkg)
-    
-    # 安装Python包
-    for pkg in packages['python']:
-        if '==' in pkg:
-            pkg_name = pkg.split('==')[0]
-            pkg_version = pkg.split('==')[1]
-            os.system(f"pip uninstall -y {pkg_name} > /dev/null 2>&1")
-            os.system(f"pip install {pkg} > /dev/null 2>&1")
-        else:
-            os.system(f"pip install {pkg} > /dev/null 2>&1")
-    
-    logger.info('软件包列表更新完成')
+    """Install a package using apt."""
+    print(f"Installing {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():
-    """结束所有frpc进程"""
     try:
+        # 使用pkill命令结束所有frpc进程
         subprocess.run(['pkill', '-f', 'frpc'], check=True)
-        logger.info("所有frpc进程已被结束")
+        print("所有frpc进程已被结束。")
     except subprocess.CalledProcessError as e:
-        logger.error(f"结束frpc进程时出错: {e}")
-
-# 运行系统更新
-update_packages()
-clear_output(wait=True)  # 清除输出
-
-# 关闭可能运行的frpc进程
+        # 如果pkill命令失败，打印错误信息
+        print(f"结束frpc进程时出错: {e}")
 kill_frpc_processes()
 
-def run_command(cmd, check=True, shell=True, silent=False):
-    """运行系统命令的通用函数"""
-    try:
-        kwargs = {
-            'shell': shell,
-            'check': check
-        }
-        
-        if silent:
-            kwargs.update({
-                'stdout': subprocess.DEVNULL,
-                'stderr': subprocess.DEVNULL
-            })
-            
-        return subprocess.run(cmd, **kwargs)
-    except subprocess.CalledProcessError as e:
-        logger.error(f"命令执行失败: {e}")
-        return None
 
 # Oneapi中转
 def Oneapi():
@@ -242,88 +186,177 @@ def Oneapi():
     print('-----------Oneapi中转结束-------------')
 # Oneapi()
 
-# SSH相关功能
+# 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():
-    """安装和配置SSH服务器"""
-    logger.info('开始配置SSH服务')
-    
-    # 安装SSH服务器
-    run_command("apt update", silent=True)
-    run_command("apt install openssh-server -y", silent=True)
-    run_command("apt-get install vim -y", silent=True)
-    
-    # 配置SSH
-    run_command("sudo sed -i '/PasswordAuthentication/s/^#//g' /etc/ssh/ssh_config")
-    run_command("sudo sed -i '/PermitRootLogin prohibit-password/s/prohibit-password/yes/' /etc/ssh/sshd_config")
+    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)
+    
+    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")
-    run_command("/etc/init.d/ssh restart")
-    run_command("echo 'root:qilan' | sudo chpasswd")
-    run_command("echo 'PermitRootLogin yes' | sudo tee -a /etc/ssh/sshd_config")
-    run_command("service ssh restart")
-    run_command("export LD_LIBRARY_PATH=$(echo $LD_LIBRARY_PATH | tr ':' '\n' | grep -v '/opt/conda/lib' | paste -sd ':') ")
-    
-    logger.info('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
+
+def update_last_uploaded_size(size):
+    global last_uploaded_size
+    last_uploaded_size = size
+
+def compress_folder():
+    global last_uploaded_size  # 声明使用全局变量
+
+    # 清理并创建目录 /a
+    if os.path.exists('/a'):
+        subprocess.run(['rm', '-r', '/a/'])
+
+    os.makedirs('/a', exist_ok=True)
+
+    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:
+            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
+            )
+        except subprocess.CalledProcessError as e:
+            print(f"Command failed with return code {e.returncode}")
+
+        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
+
+        print(f"Data compressed into {file_path}")
+        
+        file_size = os.path.getsize(file_path)  # 获取压缩包的大小
+        print('文件大小:', file_size, '上次文件大小：', last_uploaded_size,file_size * 1024 ** 2)
+        
+        # 判断是否大于800MB (800MB = 800 * 1024 * 1024 字节)
+        if file_size < (400 * 1024 ** 2):  
+            print("文件小于800MB，不进行上传。")
+            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密钥对"""
-    logger.info("生成SSH密钥对")
-    # 删除已有的SSH密钥
+    # 生成 SSH 密钥对，并捕获输出和错误信息
     os.system("rm -f ~/.ssh/id_rsa ~/.ssh/id_rsa.pub")
-    
-    # 生成���的SSH密钥
     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
-        )
-        logger.info("SSH密钥对已生成")
-        
-        # 设置权限
-        os.system('chmod 600 ~/.ssh/id_rsa')
-        return True
+        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:
-        error_msg = e.stderr.decode() if e.stderr else str(e)
-        logger.error(f"SSH密钥生成失败: {error_msg}")
-        return False
+        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):
-    """将公钥复制到远程服务器"""
-    logger.info(f"正在将公钥复制到 {user}@{host}:{port}")
+    # 使用 pexpect 自动输入密码来复制公钥
     try:
         command = f"ssh-copy-id -o StrictHostKeyChecking=no -p {port} {user}@{host}"
         child = pexpect.spawn(command)
 
         # 等待密码提示并发送密码
-        child.expect("password:", timeout=15)
+        child.expect("password:", timeout=10)  # 增加超时时间
         child.sendline(password)
 
-        # 等待命令完成
+        # 等待命令完成并输出结果
         child.expect(pexpect.EOF)
-        logger.info("公钥已成功复制到远程服务器")
-        return True
+        
+        print(child.before.decode())  # 打印输出结果
+        
     except Exception as e:
-        logger.error(f"复制公钥失败: {e}")
-        return False
+        print(f"An error occurred: {e}")
 
-def check_ssh_connection(host, port, username, password):
-    """检查SSH连接是否可用"""
-    try:
-        client = paramiko.SSHClient()
-        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        client.connect(hostname=host, port=int(port), username=username, password=password, timeout=10)
-        client.close()
-        logger.info(f"SSH连接到 {username}@{host}:{port} 成功")
-        return True
-    except Exception as e:
-        logger.error(f"SSH连接失败: {e}")
-        return False
 
+# 生成 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):
-    """配置rsync守护进程"""
     rsyncd_conf_content = f"""
 port = {port}
 [qilan]
@@ -334,22 +367,16 @@ port = {port}
 """
     with open('/etc/rsyncd.conf', 'w') as f:
         f.write(rsyncd_conf_content.strip())
-    logger.info(f"已配置rsync守护进程，端口为 {port}")
+    print(f"Successfully wrote to /etc/rsyncd.conf for module .")
     
-    # 启动rsync守护进程
-    run_command("sudo rsync --daemon")
-    run_command("ps aux | grep rsync", silent=True)
+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,
-        read=retries,
-        connect=retries,
-        backoff_factor=backoff_factor,
-        status_forcelist=status_forcelist,
-    )
+    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)
@@ -363,562 +390,324 @@ import logging
 
 import paramiko
 
-def monitor_port(port=8000, check_interval=5):
-    """监控指定端口，如果未使用则重新启动SillyTavern"""
-    logger.info(f"开始监控端口 {port}")
-    while True:
-        try:
-            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
-                result = sock.connect_ex(('localhost', port))
-                if result == 0:
-                    logger.info(f"端口 {port} 正在使用中")
-                else:
-                    logger.warning(f"端口 {port} 未被使用，尝试重新启动SillyTavern")
-                    threading.Thread(target=Run_SillyTavern, daemon=True).start()
-        except Exception as e:
-            logger.error(f"端口监控异常: {e}")
-            
-        time.sleep(check_interval)
-
-def Run_SillyTavern():
-    """运行SillyTavern服务器"""
-    logger.info("尝试启动SillyTavern")
+def check_ssh_connection(host, port, username, password):
     try:
-        # 确保在正确的目录中
-        os.chdir(data_folder)
-        
-        # 多次尝试启动，提高成功率
-        for i in range(5):
-            logger.info(f"第{i+1}次尝试启动SillyTavern")
-            result = run_command(f'yes | sh {data_folder}/start.sh', silent=True)
-            if result and result.returncode == 0:
-                logger.info("SillyTavern已成功启动")
-                break
-            time.sleep(2)
-            
-        logger.info("SillyTavern启动过程完成")
+        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:
-        logger.error(f"启动SillyTavern时发生异常: {e}")
+        print(f"SSH 连接失败: {e}")
+        return False
 
-def check_api_status():
-    """检查SillyTavern API是否正常运行"""
-    # 检查本地服务是否启动
-    max_retries = 30
-    retry_count = 0
-    
-    # 第一步：检查本地API是否启动
-    logger.info("检查SillyTavern本地API是否启动")
-    while retry_count < max_retries:
-        retry_count += 1
-        
+
+
+
+# 配置日志
+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):
-            logger.error(f"数据目录 {data_folder} 不存在，终止检测")
-            return False
-            
+            logging.error(f"/sillytavern/ 文件不存在，结束检测")
+            break
         try:
             url = "http://127.0.0.1:8000/v1"
-            response = requests.get(url, timeout=5)
-            
+            response = requests.get(url, timeout=30)
+
             if response.status_code == 403:
-                logger.info("SillyTavern本地API已启动")
+                print("SillyTavern已经启动")
                 break
             
-            logger.warning(f"SillyTavern未启动，状态码: {response.status_code}，重试次数: {retry_count}")
+            print("SillyTavern未启动，状态码:", response.status_code, n)
+
         except requests.exceptions.RequestException as e:
-            logger.warning(f"SillyTavern未启动: {e}，重试次数: {retry_count}")
+            print(f"SillyTavern未启动3: {e}, 尝试次数: {n}")
         
-        if retry_count >= max_retries:
-            logger.error("SillyTavern本地API启动检测超时")
-            return False
-            
         time.sleep(5)
     
-    # 第二步：检查远程API是否可访问
-    logger.info("本地API已启动，开始检测远程API状态")
-    retry_count = 0
-    retry_limit = 10
-    sync_attempts = 0
-    
-    while retry_count < retry_limit:
-        retry_count += 1
-        
-        if sync_attempts >= 3:
-            logger.error("同步尝试次数过多，终止检测")
+    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"
         try:
-            response = requests_retry_session().get(url, timeout=10)
+            response = requests_retry_session().get(url, timeout=30)
             response.raise_for_status()
             response_json = response.json()
-            
-            logger.info(f"远程API返回信息: {response_json}")
-            
+            print("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
             if "token" in response_json:
-                logger.info("远程API正常，检测到token")
-                try:
-                    # 使用rsync从远程同步数据
-                    result = run_command(
-                        f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",
-                        check=True
-                    )
-                    if result and result.returncode == 0:
-                        logger.info("数据同步成功")
-                        return True
-                except Exception as e:
-                    sync_attempts += 1
-                    logger.error(f"数据同步失败: {e}，尝试次数: {sync_attempts}")
-                    if sync_attempts < 3:
-                        # 重新生成SSH密钥重试
-                        generate_ssh_key()
+                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:
-                logger.warning(f"远程API返回数据中没有token: {response_json}")
-                
+                print("%s 接口返回信息： %s", url, response_json)  # 修正日志记录
         except requests.exceptions.ConnectionError as e:
-            logger.error(f"远程API连接异常: {e}，重试次数: {retry_count}")
-            sync_attempts += 1
+            print(f"接口异常1: {e}, 尝试次数: {n}, nn: {nn}")
+            # time.sleep(3)
+            nn += 1
+            if nn > 5:
+                break
         except requests.exceptions.Timeout as e:
-            logger.error(f"远程API超时: {e}")
+            print(f"接口异常2: {e}, 尝试次数: {n}")
             break
         except requests.exceptions.RequestException as e:
-            logger.error(f"远程API请求异常: {e}")
+            print(f"接口异常3: {e}, 尝试次数: {n}")
             break
         
         time.sleep(5)
-    
-    return False
 
-def frp(configs, backstage=True):
-    """启动FRP代理客户端"""
-    logger.info('开始配置FRP客户端')
-    
-    # 杀死之前可能运行的frpc进程
-    kill_frpc_processes()
-    
-    # 遍历配置启动FRP
-    for idx, (config_data, config_file_path) in enumerate(configs):
-        # 写入配置文件
-        with open(config_file_path, 'w') as config_file:
-            config_file.write(config_data)
-        
-        # 构建启动命令
-        frpc_cmd = ['/content/frp/frpc', '-c', config_file_path]
-        
-        if backstage:
-            # 后台运行
-            process = subprocess.Popen(frpc_cmd)
-            logger.info(f"FRP客户端[{idx}]已在后台启动，PID: {process.pid}")
-        else:
-            # 前台运行（阻塞）
-            logger.info(f"FRP客户端[{idx}]正在前台启动")
-            run_command(f'/content/frp/frpc -c {config_file_path}', shell=True)
-    
-    logger.info('所有FRP客户端已启动')
+
+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地址"""
-    try:
-        response = requests.get("https://ipinfo.io/ip", timeout=10)
-        ip = response.text.strip()
-        logger.info(f"当前公共IP: {ip}")
-        return ip
-    except Exception as e:
-        logger.error(f"获取IP地址失败: {e}")
-        return "未知"
+    """获取当前公共 IP 地址"""
+    response = requests.get("https://ipinfo.io/ip")
+    return response.text.strip()
 
 def get_geo_info(ip_address):
-    """根据IP地址获取地理位置信息"""
-    url = "https://api.qjqq.cn/api/Local"
+    """根据 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"
     }
     
-    try:
-        response = requests_retry_session().get(url, headers=headers, timeout=10)
+    response = requests.get(url, headers=headers)
+    
+    if response.status_code == 200:
+        geo_info = response.json()
         
-        if response.status_code == 200:
-            geo_info = response.json()
-            
-            if geo_info.get('code') == 200:
-                data = geo_info.get('data', {})
-                result = {
-                    'ip': data.get('ip', "未知"),
-                    'country': data.get('country', "未知"),
-                    'isp': data.get('isp', "未知")
-                }
-                logger.info(f"获取地理信息成功: {result}")
-                return result
-                
-        logger.warning(f"获取地理信息失败，状态码: {response.status_code}")
-        return None
-    except Exception as e:
-        logger.error(f"获取地理信息时发生错误: {e}")
-        return None
+        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小时，转换为中国时区）"""
-    try:
-        # 获取系统启动时间
-        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")
-    except Exception as e:
-        logger.error(f"计算下次接力时间失败: {e}")
-        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    # 获取系统启动时间
+    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):
-    """更新登录页面中的接力时间和IP信息"""
     try:
-        # 检查文件是否存在
-        if not os.path.exists(file_path):
-            logger.error(f"文件{file_path}不存在，无法更新信息")
-            return False
-            
-        # 获取当前IP地址和地理信息
+        # 获取当前 IP 地址和地理信息
         ip_address = get_current_ip()
         geo_info = get_geo_info(ip_address)
         next_relay_time = get_next_relay_time()
         
-        if geo_info is None:
-            logger.error("无法获取地理信息，更新文件信息失败")
-            return False
+        if geo_info is not None:
+            # 读取文件内容
+            with open(file_path, 'r', encoding='utf-8') as file:
+                content = file.read()
             
-        # 读取文件内容
-        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[{geo_info["ip"]}] 国家 [{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)
-        
-        logger.info("成功更新信息:")
-        logger.info(f"接力时间: {next_relay_time}")
-        logger.info(f"IP信息: IP[{geo_info['ip']}] 国家 [{geo_info['country']}] IPS[{geo_info['isp']}]")
-        return True
-        
-    except Exception as e:
-        logger.error(f"更新文件信息时发生错误: {e}")
-        return False
-
-def update_last_uploaded_size(size):
-    """更新上次上传的文件大小"""
-    global last_uploaded_size
-    last_uploaded_size = size
-    logger.info(f"上次上传文件大小已更新为: {size} 字节")
-
-def compress_folder():
-    """压缩SillyTavern文件夹并上传到Kaggle"""
-    global last_uploaded_size  # 声明使用全局变量
-
-    # 清理并创建目录 /a
-    if os.path.exists('/a'):
-        run_command('rm -r /a/')
-
-    os.makedirs('/a', exist_ok=True)
-
-    with lock:  # 使用锁防止多线程冲突
-        # 检查文件是否已存在
-        if os.path.exists(zip_file_path):
-            logger.info(f"压缩文件 {zip_file_path} 已存在，跳过本次压缩")
-            return
-        
-        logger.info('开始压缩数据')
-        
-        # 使用pigz进行多核压缩以提高效率
-        try:
-            result = run_command(
-                f'tar -cvf - {data_folder} | pigz -p 2 -1 > {zip_file_path} 2> /dev/null',
-                shell=True,
-                check=True,
-                silent=True
-            )
-        except Exception as e:
-            logger.error(f"压缩命令失败: {e}")
-            return
-
-        logger.info('重命名压缩后的文件')
-        file_path = "/a/sillytavern.ctk"
-        
-        run_command(['mv', zip_file_path, file_path], shell=False)
-        
-        # 检查压缩是否成功
-        if not os.path.exists(file_path):
-            logger.error("压缩失败，文件不存在")
-            return
-
-        logger.info(f"数据已压缩到 {file_path}")
-        
-        # 获取文件大小
-        file_size = os.path.getsize(file_path)
-        logger.info(f'文件大小: {file_size} 字节, 上次文件大小: {last_uploaded_size} 字节')
-        
-        # 文件大小必须超过400MB才会上传
-        min_size = 400 * 1024 * 1024  # 400MB
-        if file_size < min_size:  
-            logger.info(f"文件小于{min_size/(1024*1024)}MB，不进行上传")
-            return
-        
-        # 检查是否需要上传
-        if last_uploaded_size == -1 or file_size > last_uploaded_size:
-            # 首次运行或文件变大
-            if last_uploaded_size == -1:
-                logger.info("首次运行，准备上传...")
-            else:
-                logger.info(f"新文件 {file_path} 大于上次上传的大小，准备上传...")
+            # 替换接力时间
+            time_pattern = r'接力时间\[.*?\]'
+            time_replacement = f'接力时间[{next_relay_time}]'
+            content = re.sub(time_pattern, time_replacement, content)
             
-            # 更新上传大小记录
-            update_last_uploaded_size(file_size)
+            # 替换 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(metadata_file_path, 'w') as json_fid:
-                json.dump(kaggle_metadata, json_fid)
+            # 写回文件
+            with open(file_path, 'w', encoding='utf-8') as file:
+                file.write(content)
             
-            # 上传到Kaggle
-            logger.info("开始上传到Kaggle...")
-            os.system("kaggle datasets version -m 'new version message' -p /a")
-            logger.info("上传完成")
-        else:
-            logger.info(f"新文件 {file_path} 不大于上次上传的大小，跳过上传")
-
-def repeat_task():
-    """定期压缩和上传的后台任务"""
-    logger.info('打包备份线程已启动')
-    try:
-        while True:
-            logger.info('等待下一次打包时间...')
-            time.sleep(18000)  # 5小时执行一次
-            compress_folder()
-    except Exception as e:
-        logger.error(f"打包线程异常: {e}")
-    logger.info('打包线程已结束')
-
-def setup_tavern_environment():
-    """设置SillyTavern运行环境"""
-    logger.info("设置SillyTavern运行环境")
+            print(f"成功更新信息：")
+            print(f"接力时间: {next_relay_time}")
+            print(f"IP信息: IP[{ip_address}] 国家 [{geo_info['country']}] IPS[{geo_info['isp']}]")
     
-    try:
-        # 切换到SillyTavern目录
-        os.chdir(data_folder)
-        
-        # 安装Node.js环境
-        run_command("nvm install node", silent=True)
-        run_command("nvm use node", silent=True)
-        
-        # 安装依赖
-        run_command("npm install -y", silent=True)
-        
-        # 首次运行SillyTavern
-        try:
-            run_command(f'yes | sh {data_folder}/start.sh', check=False, silent=True)
-            logger.info("SillyTavern环境设置完成")
-            return True
-        except Exception as e:
-            logger.error(f"首次启动SillyTavern失败: {e}")
-            return False
     except Exception as e:
-        logger.error(f"设置SillyTavern环境时出错: {e}")
-        return False
+        print(f"发生错误: {e}")
 
-def SillyTavern():
-    """安装和配置SillyTavern"""
-    logger.info('开始安装SillyTavern')
-    
-    # 设置Kaggle凭证
-    setup_kaggle()
-    
-    # 清除输出
-    clear_output()
-    
-    # 清理旧文件
-    run_command(f"rm -rf /a /sillytavern /*.zi* {data_folder}", silent=True)
-    run_command(f"mkdir -p {data_folder}", silent=True)
-    
-    # 切换到根目录
-    os.chdir('/')
-    
-    # 尝试从Kaggle下载
-    download_success = download_from_kaggle()
-    
-    if not download_success:
-        logger.warning("从Kaggle下载失败，尝试使用rsync同步")
-        # 使用SSH同步备份方案
-        generate_ssh_key()
-        copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
-        
-        try:
-            run_command(
-                f"rsync -avz --timeout=600 -e 'ssh -p {ssh_port} -o StrictHostKeyChecking=no' root@{ssh_url}:{data_folder}/ {data_folder}/",
-                check=True
-            )
-            logger.info("通过rsync成功同步数据")
-        except Exception as e:
-            logger.error(f"rsync同步失败: {e}")
-            return False
-    else:
-        # 如果下载成功，解压数据
-        extract_success = extract_tavern_data()
-        if not extract_success:
-            logger.error("解压SillyTavern数据失败")
-            return False
-    
-    # 设置环境并启动
-    setup_success = setup_tavern_environment()
-    if not setup_success:
-        logger.error("设置SillyTavern环境失败")
-        return False
-    
-    # 在后台启动SillyTavern
-    backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
-    backup_thread.start()
-    
-    logger.info('SillyTavern安装和配置完成')
-    return True
+import socket
+import subprocess
+import time
 
-# 主函���
-if __name__ == "__main__":
-    # 安装SSH服务
-    ssh()
-    
-    # 生成SSH密钥
-    generate_ssh_key()
-    
-    # 复制SSH公钥到远程服务器
-    copy_public_key_to_remote(ssh_url, ssh_port, "root", "qilan")
-    
-    # 配置rsync
-    write_rsyncd_conf(data_folder)
-    
-    # 启动SillyTavern
-    tavern_thread = threading.Thread(target=SillyTavern, daemon=True)
-    tavern_thread.start()
-    tavern_thread.join(timeout=60)  # 等待最多60秒
-    
-    # 检查API状态
-    api_status = check_api_status()
-    
-    # 如果SillyTavern已安装成功
-    if os.path.exists(f'{data_folder}/start.sh'):
-        # 更新登录页面信息
-        replace_info_in_file(f'{data_folder}/public/login.html')
-        
-        # 启动备份线程
-        backup_thread = threading.Thread(target=repeat_task, daemon=True)
-        backup_thread.start()
-        
-        logger.info("开始配置网络连接")
-        # 服务状态设为可用
-        st_status = True
-        
-        # 启动FRP代理
-        frp(configs, True)
-        
-        # 启动端口监控
-        threading.Thread(target=monitor_port, daemon=True).start()
-        
-        # 监控备份线程状态
-        while True:
-            if backup_thread.is_alive():
-                logger.info("备份线程正在运行...")
+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:
-                logger.warning("备份线程已停止，重新启动")
-                backup_thread = threading.Thread(target=repeat_task, daemon=True)
+                print(f"端口 8000 未被使用")
+                backup_thread = threading.Thread(target=Run_SillyTavern, daemon=True)
                 backup_thread.start()
-                break
-            time.sleep(30)  # 每30秒检查一次
-        
-        # 运行一次压缩备份
-        compress_folder()
-    else:
-        logger.error(f"{data_folder} 文件夹不存在，安装失败")
-
-def setup_kaggle():
-    """设置Kaggle API凭证"""
-    logger.info("设置Kaggle API凭证")
-    # 创建目录并写入kaggle.json
-    os.makedirs("~/.kaggle", exist_ok=True)
+        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}")
+def SillyTavern():
+    print('-----------SillyTavern开始-------------')
+    # 创建目录并写入 kaggle.json
+    os.system("mkdir -p ~/.kaggle")
     file_path = '/root/.kaggle/kaggle.json'
     with open(file_path, 'w') as json_file:
         json.dump(ini_content, json_file, indent=4)
-    
-    # 设置权限
     os.system("chmod 600 ~/.kaggle/kaggle.json")
-    logger.info("Kaggle凭证设置完成")
 
-def download_from_kaggle():
-    """从Kaggle下载SillyTavern数据"""
-    logger.info(f"开始从Kaggle下载数据集 {huggingface_name}/{huggingface_Data_name}")
-    
-    max_attempts = 6
-    for attempt in range(1, max_attempts + 1):
-        logger.info(f"第{attempt}次尝试下载")
-        
+    clear_output()
+
+    os.system(f"rm -r /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:
         # 执行下载命令
-        run_command(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /", silent=True)
-        
+        if download_n > 6:
+            break
+        os.system(f"kaggle datasets download {huggingface_name}/{huggingface_Data_name} -p /")
         # 检查文件是否存在
         if os.path.exists(f'/{huggingface_Data_name}.zip'):
-            logger.info(f"{huggingface_Data_name}.zip 下载成功")
-            return True
-            
-        logger.warning(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()
+    else:
         
-        if attempt < max_attempts:
-            logger.info(f"等待5分钟后重试...")
-            time.sleep(300)  # 等待5分钟再重试
-    
-    logger.error("多次尝试下载失败")
-    return False
+        # 如果文件存在，可以继续执行后续代码
+        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")
 
-def extract_tavern_data():
-    """解压SillyTavern数据"""
-    logger.info("开始解压SillyTavern数据")
-    
-    # 检查目标文件
-    zip_path = f'/{huggingface_Data_name}.zip'
-    if not os.path.exists(zip_path):
-        logger.error(f"文件 {zip_path} 不存在，无法解压")
-        return False
-        
-    try:
-        # 解压缩文件
-        run_command(f"7z x {zip_path} -o/ -y", silent=True)
         
-        # 重命名解压后的文件
-        if os.path.exists('/sillytavern.tck'):
-            run_command("mv /sillytavern.tck sillytavern.tar.gz")
+        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}")
+        os.system("nvm install node")
+        os.system("nvm use node")
+        os.system("npm install -y")
+        try:
+            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}")
         
-        if os.path.exists('/sillytavern.ctk'):
-            run_command("mv /sillytavern.ctk sillytavern.tar.gz")
         
-        # 使用pigz解压tar.gz文件
-        if os.path.exists('/sillytavern.tar.gz'):
-            run_command("tar -xvpf /sillytavern.tar.gz -C / --use-compress-program=pigz > /dev/null", silent=True)
-            logger.info("SillyTavern数据解压完成")
-            
-            # 清理下载和临时文件
-            run_command(f"rm -r {zip_path} /sillytavern.tar.gz", silent=True)
-            return True
-        else:
-            logger.error("解压后的tar.gz文件不存在")
-            return False
-    except Exception as e:
-        logger.error(f"解压SillyTavern数据时出错: {e}")
-        return False
+        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()
+
+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)
+
+    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)
+
+else:
+    print("/sillytavern 文件不存在结束执行")
+compress_folder()