这是你之前让我改的项目结构
E:\AI_System\
├── agent\
│ ├── __init__.py
│ └── autonomous_agent.py
├── cognitive_arch\
│ ├── __init__.py
│ └── life_scheduler.py
├── config\
│ ├── __init__.py
│ └── config_loader.py
├── core\
│ ├── __init__.py
│ └── environment_interface.py
├── web_ui\
│ ├── templates\
│ ├── static\
│ └── server.py
├── logs\
├── model_cache\
└── .gitignore
这是我的server.py：”# E:\AI_System\web_ui\server.py
import sys
import os
import time
import logging
import json
import traceback
import threading
from flask import Flask, jsonify, request, render_template, send_from_directory, Response
# ========== 初始日志设置 ==========
# 创建临时日志记录器用于启动阶段
temp_logger = logging.getLogger('StartupLogger')
temp_logger.setLevel(logging.DEBUG)
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
temp_logger.addHandler(console_handler)
# ========== 解决路径问题 ==========
base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, base_dir)
temp_logger.info(f"项目根
目录: {base_dir}")
# 添加所有必要的子
目录
sub_dirs = ['agent', 'core', 'utils', 'config', 'cognitive_arch']
for sub_dir in sub_dirs:
full_path = os.path.join(base_dir, sub_dir)
if os.path.exists(full_path):
sys.path.insert(0, full_path)
temp_logger.info(f"添加路径: {full_path}")
else:
temp_logger.warning(f"
目录不存在: {full_path}")
# ========== 配置加载 ==========
class TempConfig:
"""临时配置类，确保所有必要属性都存在"""
AGENT_PATH = os.path.join(base_dir, 'agent')
WEB_UI_PATH = os.path.join(base_dir, 'web_ui')
MODEL_CACHE_DIR = os.path.join(base_dir, 'model_cache')
LOG_DIR = os.path.join(base_dir, 'logs')
HOST = '0.0.0.0'
PORT = 8000
SECRET_KEY = 'temp-secret-key'
LOG_LEVEL = 'INFO'
USE_GPU = False
DEFAULT_MODEL = 'minimal-model'
ENV = 'development'
# 生活系统配置
LIFE_SCHEDULE = {
"wake_up": "08:00",
"breakfast": "08:30",
"lunch": "12:30",
"dinner": "19:00",
"sleep": "23:00"
}
# 尝试导入配置
try:
from config.config_loader import config
temp_logger.info("✅ 使用config_loader中的配置")
except ImportError as e:
config = TempConfig()
temp_logger.error(f"❌ 配置模块导入失败: {str(e)}")
temp_logger.warning(f"⚠️ 使用临时配置")
temp_logger.info(f"请检查以下路径是否存在:")
temp_logger.info(f"1. {os.path.join(base_dir, 'config/config_loader.py')}")
temp_logger.info(f"2. {os.path.join(base_dir, 'config/__init__.py')}")
# ========== 配置Flask应用 ==========
app = Flask(__name__,
template_folder='templates',
static_folder='static')
# ========== 安全日志处理 ==========
def safe_log(message):
"""安全处理日志中的Unicode字符"""
try:
return message.encode('utf-8', 'ignore').decode('utf-8')
except:
return message.replace('❌', '[ERROR]').replace('⏳', '[WAIT]').replace('‼️', '[CRITICAL]').replace('✅',
'[OK]').replace(
'🚀', '[LAUNCH]')
# ========== 正式日志设置 ==========
logger = logging.getLogger('WebServer')
logger.setLevel(getattr(logging, config.LOG_LEVEL.upper(), logging.INFO))
# 日志格式
log_formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# 文件日志处理器
try:
# 确保日志
目录存在
os.makedirs(config.LOG_DIR, exist_ok=True)
from logging.handlers import TimedRotatingFileHandler
file_handler = TimedRotatingFileHandler(
os.path.join(config.LOG_DIR, 'web_server.log'),
when='midnight',
backupCount=30,
encoding='utf-8'
)
file_handler.setFormatter(log_formatter)
logger.addHandler(file_handler)
logger.info("✅ 文件日志处理器初始化成功")
except Exception as e:
logger.warning(f"⚠️ 文件日志处理器创建失败: {str(e)}")
# 控制台日志处理器
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
logger.addHandler(console_handler)
# 移除临时日志处理器
temp_logger.removeHandler(console_handler)
# 重写logger方法以处理Unicode
original_info = logger.info
original_error = logger.error
original_warning = logger.warning
original_critical = logger.critical
def safe_logger(original_func):
def wrapper(msg, *args, **kwargs):
try:
original_func(safe_log(msg), *args, **kwargs)
except UnicodeEncodeError:
ascii_msg = msg.encode('ascii', 'ignore').decode('ascii')
original_func(ascii_msg, *args, **kwargs)
return wrapper
logger.info = safe_logger(original_info)
logger.error = safe_logger(original_error)
logger.warning = safe_logger(original_warning)
logger.critical = safe_logger(original_critical)
# ========== 全局智能体实例 ==========
ai_agent = None
life_scheduler = None
# ========== 生活系统初始化 ==========
try:
from cognitive_arch.life_scheduler import LifeScheduler
# 初始化生活系统
life_scheduler = LifeScheduler(
daily_schedule=config.LIFE_SCHEDULE,
log_dir=config.LOG_DIR
)
logger.info("✅ 生活系统初始化成功")
# 生活状态更新线程
def update_life_status():
"""后台线程定期更新生活状态"""
while True:
try:
# 获取当前时间
current_hour = time.localtime().
tm_hour
# 根据时间执行相应活动
if 8 <= current_hour < 9:
life_scheduler.wake_up()
elif 12 <= current_hour < 13:
life_scheduler.have_meal("lunch")
elif 19 <= current极客 < 20:
life_scheduler.have_meal("dinner")
elif 23 <= current_hour or current_hour < 6:
life_scheduler.go_to_sleep()
time.sleep(60) # 每分钟更新一次
except Exception as e:
logger.error(f"生活系统更新失败: {str(e)}")
time.sleep(300) # 出错后等待5分钟再重试
# 启动后台线程
life_thread = threading.Thread(target=update_life_status, daemon=True)
life_thread.start()
logger.info("✅ 生活系统后台线程已启动")
except ImportError as e:
logger.error(f"❌ 生活系统模块导入失败: {str(e)}")
logger.warning("⚠️ 生活系统功能将不可用")
except Exception as e:
logger.error(f"❌ 生活系统初始化失败: {str(e)}")
logger.warning("⚠️ 生活系统功能将不可用")
# ========== 智能体初始化 ==========
logger.info("=" * 50)
logger.info("正在使用统一配置初始化智能体核心模块...")
logger.info(f"智能体路径: {config.AGENT_PATH}")
logger.info(f"模型缓存
目录: {config.MODEL_CACHE_DIR}")
logger.info(f"默认模型: {config.DEFAULT_MODEL}")
logger.info(f"使用GPU: {config.USE_GPU}")
max_retries = 3
retry_delay = 2 # 秒
for attempt in range(max_retries):
try:
# 动态导入智能体模块
from agent.autonomous_agent import AutonomousAgent
ai_agent = AutonomousAgent(
model_path=config.AGENT_PATH,
cache_dir=config.MODEL_CACHE_DIR,
use_gpu=config.USE_GPU,
default_model=config.DEFAULT_MODEL
)
logger.info("✅ 智能体核心模块初始化成功")
break
except ImportError as ie:
logger.error(f"❌ 智能体模块导入失败: {str(ie)}")
if attempt < max_retries - 1:
logger.info(f"⏳ {retry_delay}秒后重试...")
time.sleep(retry_delay)
else:
logger.critical("‼️ 智能体模块导入彻底失败")
ai_agent = None
except Exception as e:
logger.error(f"❌ 智能体初始化失败 (尝试 {attempt + 1}/{max_retries}): {str(e)}")
if attempt < max_retries - 1:
logger.info(f"⏳ {retry_delay}秒后重试...")
time.sleep(retry_delay)
else:
logger.critical("‼️ 智能体初始化彻底失败，部分功能将不可用")
ai_agent = None
# ========== 生活系统路由 ==========
@app.route('/life')
def life_dashboard():
"""生活状态仪表盘页面"""
return render_template('life_dashboard.h
tml')
@app.route('/api/life/status')
def get_life_status():
"""获取生活系统状态的API端点"""
if not life_scheduler:
return jsonify({
"success": False,
"error": "生活系统未初始化"
}), 503
try:
# 获取当前状态
current_state = life_scheduler.get_current_state()
# 获取计划表
schedule = life_scheduler.daily_schedule
# 获取活动记录
recent_activities = life_scheduler.get_recent_activities(10)
return jsonify({
"success": True,
"current_activity": current_state["current_activity"],
"next_scheduled": current_state["next_scheduled"],
"schedule": schedule,
"recent_activities": recent_activities
})
except Exception as e:
logger.error(f"获取生活状态失败: {traceback.format_exc()}")
return jsonify({
"success": False,
"error": str(e)
}), 500
@app.route('/adjust_schedule', methods=['POST'])
def adjust_schedule():
"""调整生活计划表"""
if not life_scheduler:
return jsonify({
"success": False,
"error": "生活系统未初始化"
}), 503
try:
data = request.json
adjus
tments = data.get("adjus
tments", {})
# 验证调整数据
valid_activities = ["wake_up", "breakfast", "lunch", "dinner", "sleep"]
for activity, new_time in adjus
tments.items():
if activity not in valid_activities:
raise ValueError(f"无效的活动类型: {activity}")
# 验证时间格式 (HH:MM)
if not isinstance(new_time, str) or len(new_time) != 5 or new_time[2] != ':':
raise ValueError(f"无效的时间格式: {new_time}")
# 应用调整
life_scheduler.adjust_schedule(adjus
tments)
return jsonify({
"success": True,
"message": "计划表已更新",
"new_schedule": life_scheduler.daily_schedule
})
except Exception as e:
logger.error(f"调整作息时间失败: {traceback.format_exc()}")
return jsonify({
"success": False,
"error": str(e)
}), 400
# ========== 核心路由 ==========
@app.route('/')
def index():
"""首页路由 - 渲染前端界面"""
return render_template('agent_interface.h
tml')
@app.route('/static/<path:filename>')
def static_files(filename):
"""提供静态文件"""
try:
return send_from_directory(app.static_folder, filename)
except Exception as e:
logger.error(f"静态文件服务失败: {filename} - {str(e)}")
return jsonify({"error": "文件未找到"}), 404
@app.route('/status')
def status():
"""系统状态检查"""
if ai_agent:
try:
status_data = ai_agent.get_status()
# 添加服务器状态信息
status_data.update({
"server": {
"status": "running",
"uptime": time.time() - start_time,
"version": "1.0.0",
"config": {
"host": config.HOST,
"port": config.PORT,
"log_level": config.LOG_LEVEL,
"default_model": config.DEFAULT_MODEL
}
},
"life_system": life_scheduler.get_current_state() if life_scheduler else None
})
return jsonify(status_data)
except Exception as e:
logger.error(f"获取状态失败: {traceback.format_exc()}")
return jsonify({"error": "内部错误", "details": str(e)}), 500
return jsonify({"status": "agent_not_initialized"}), 503
@app.route('/chat', methods=['POST'])
def chat():
"""处理聊天请求，支持流式响应"""
if ai_agent is None:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
user_input = data.get('message', '')
user_id = data.get('user_id', 'default')
stream = data.get('stream', False)
logger.info(f"聊天请求: 用户={user_id}, 流式={stream}, 内容长度={len(user_input)}")
if not stream:
response = ai_agent.process_input(user_input, user_id)
return jsonify({"response": response})
def generate():
try:
def stream_callback(chunk, is_
final=False):
event_data = json.dumps({'chunk': chunk, '
final': is_
final})
yield f"data: {event_data}\n\n"
response_gen = ai_agent.process_input_stream(user_input, user_id, stream_callback)
for chunk in response_gen:
yield chunk
except Exception as e:
logger.error(f"流式响应生成失败: {traceback.format_exc()}")
yield "data: {\"error\": \"流式响应中断\"}\n\n"
yield "data: {\"
final\": true}\n\n"
return Response(generate(), mimetype='text/event-stream')
except Exception as e:
logger.error(f"聊天处理失败: {traceback.format_exc()}")
return jsonify({"error": "聊天处理失败", "details": str(e)}), 500
@app.route('/shutdown', methods=['POST'])
def shutdown():
"""处理关机请求"""
try:
data = request.get_json()
delay = data.get('delay', 120)
logger.info(f"收到关机请求，将在{delay}秒后关闭系统")
return jsonify({
"message": f"系统将在{delay}秒后关闭",
"timestamp": time.time(),
"shutdown_time": time.time() + delay
})
except Exception as e:
logger.error(f"关机请求失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
# ========== 环境交互路由 ==========
@app.route('/environment')
def environment_view():
"""渲染环境浏览器界面"""
return render_template('environment_view.h
tml')
@app.route('/api/explore', methods=['GET'])
def explore_directory():
"""获取指定路径的
目录内容"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
path = request.args.get('path', '')
logger.info(f"探索
目录: {path}")
if not path:
workspace_info = ai_agent.get_status().get('environment', {})
if workspace_info and 'workspace' in workspace_info:
path = workspace_info['workspace']
# 使用智能体的安全路径检查方法
if not ai_agent.is_safe_path(path):
logger.warning(f"尝试访问受限路径: {path}")
return jsonify({"error": "访问受限"}), 403
result = ai_agent.explore_environment(path)
return jsonify(result)
except Exception as e:
logger.error(f"
目录探索失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
furniture_cache = {}
CACHE_DURATION = 3600
@app.route('/api/furniture')
def get_furniture():
"""获取指定房间的家具数据"""
try:
room = request.args.get('room', 'workshop')
logger.info(f"获取家具数据: 房间={room}")
current_time = time.time()
if room in furniture_cache and current_time - furniture_cache[room]['timestamp'] < CACHE_DURATION:
logger.debug(f"使用缓存家具数据: {room}")
return jsonify(furniture_cache[room]['data'])
furniture_data = {
"workshop": [
{"type": "desk", "position": {"x": 0, "y": -1.5, "z": -3}, "rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "chair", "position": {"x": 0, "y": -1.5, "z": -1}, "rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "bookshelf", "position": {"x": 3, "y": 0, "z": -3}, "rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "computer", "position": {"x": 0.5, "y": -0.5, "z": -3.2}, "rotation": {"x": 0, "y": 0, "z": 0}}
],
"lounge": [
{"type": "sofa", "position": {"x": 0, "y": -1.5, "z": -2}, "旋
转": {"x": 0, "y": 180, "z": 0}},
{"type": "coffee_table", "position": {"x": 0, "y": -1.5, "z": -3},
"旋
转": {"x": 0, "y": 0, "z": 0}},
{"type": "tv", "position": {"x": 0, "y": 0.5, "z": -4}, "旋
转": {"x": 0, "y": 0, "z": 0}}
],
"library": [
{"type": "bookshelf", "position": {"x": -3, "y": 0, "z": -3}, "旋
转": {"x": 极客, "y": 0, "z": 0}},
{"type": "bookshelf", "position": {"x": 0, "y": 0, "z": -3}, "旋
转": {"x": 0, "y": 0, "z": 0}},
{"type": "bookshelf", "position": {"x": 3, "y": 0, "z": -3}, "旋
转": {"x": 0, "y": 0, "z": 0}},
{"type": "reading_chair", "position": {"x": 0, "y": -1.5, "z": -1},
"旋
转": {"x": 0, "y": 180, "z": 0}}
]
}
response_data = {
"room": room,
"items": furniture_data.get(room, [])
}
furniture_cache[room] = {
'data': response_data,
'timestamp': current_time
}
return jsonify(response_data)
except Exception as e:
logger.error(f"获取家具数据失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route('/api/skins')
def get_skins():
"""获取可用皮肤列表"""
try:
skins = [
{"id": "default", "name": "默认皮肤", "description": "简洁的蓝色主题", "version": "1.0"},
{"id": "midnight", "name": "午夜黑", "description": "深色主题，减少眼睛疲劳", "version": "1.2"},
{"极客": "forest", "name": "森林绿", "description": "自然绿色主题，带来平静感", "version": "1.1"},
{"id": "tech", "name": "科技蓝", "description": "未来感十足的科技主题", "version": "2.0"},
{"id": "vintage", "name": "复古黄", "description": "复古纸张色调，怀旧风格", "version": "1.5"}
]
return jsonify({
"skins": skins,
"last_updated": "2023-11-15",
"count": len(skins)
})
except Exception as e:
logger.error(f"获取皮肤列表失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route('/api/change_skin', methods=['POST'])
def change_skin():
"""更换智能体皮肤"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
skin_name = data.get('skin')
if not skin_name:
return jsonify({"error": "Missing skin parameter"}), 400
skins_response = get_skins().get_json()
skin_ids = [skin['id'] for skin in skins_response['skins']]
if skin_name not in skin_ids:
return jsonify({"error": "无效的皮肤ID"}), 400
result = ai_agent.execute_action("change_skin", {"skin_name": skin_name})
if result.get("success"):
logger.info(f"皮肤更换成功: {skin_name}")
return jsonify({"success": True, "message": f"皮肤已更换为 {skin_name}"})
else:
logger.warning(f"换肤失败: {result.get('message')}")
return jsonify({"error": result.get("message", "换肤失败")}), 500
except Exception as e:
logger.error(f"更换皮肤失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
ALLOWED_ACTIONS = ['create_directory', 'delete_path', 'move_file', 'copy_file', 'execute_command']
@app.route('/api/execute', methods=['POST'])
def execute_action():
"""执行环境动作"""
if not ai极客:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
action = data.get('action')
params = data.get('parameters', {})
if not action:
return jsonify({"error": "Missing action parameter"}), 400
if action not in ALLOWED_ACTIONS:
logger.warning(f"尝试执行未授权动作: {action}")
return jsonify({"error": "未授权的动作"}), 403
logger.info(f"执行动作: {action}, 参数: {params}")
result = ai_agent.execute_action(action, params)
if result.get("success"):
logger.info(f"动作执行成功: {action}")
else:
logger.warning(f"动作执行失败: {action} - {result.get('message')}")
return jsonify(result)
except Exception as e:
logger.error(f"动作执行失败: {action} - {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route('/api/environment_status')
def environment_status():
"""获取环境状态信息"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
status = ai_agent.get_status()
env_status = status.get('environment', {})
history = ai_agent.environment.get_exploration_history()
available_actions = ai_agent.get_available_actions()
import psutil
env_status['performance'] = {
"cpu_usage": psutil.cpu_percent(),
"memory_usage": psutil.virtual_memory().percent,
"disk_usage": psutil.disk_usage('/').percent
}
return jsonify({
"system": env_status,
"exploration_history": history,
"available_actions": available_actions,
"timestamp": time.time()
})
except Exception as e:
logger.error(f"获取环境状态失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
# ========== 智能体管理路由 ==========
@app.route('/api/agent_status')
def agent_status():
"""获取智能体的详细状态"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
core_status = ai_agent.get_status()
env_status = ai_agent.get_environment_status()
task_queue = ai_agent.get_task_queue()
task_stats = {
"total": len(task_queue),
"pending": sum(1 for t in task_queue if t['status'] == 'pending'),
"running": sum(1 for t in task_queue if t['status'] == 'running'),
"completed": sum(1 for t in task_queue if t['status'] == 'completed'),
"failed": sum(1 for t in task_queue if t['status'] == 'failed')
}
return jsonify({
"core_status": core_status,
"environment_status": env_status,
"task_queue": task_queue,
"task_stats": task_stats,
"life_status": life_scheduler.get_current_state() if life_scheduler else None,
"timestamp": time.time()
})
except Exception as e:
logger.error(f"获取智能体详细状态失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route('/api/create_directory', methods=['POST'])
def create_directory():
"""在指定路径创建新
目录"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
path = data.get('path')
if not path:
return jsonify({"error": "Missing path parameter"}), 400
path = os.path.normpath(path)
logger.info(f"创建
目录: {path}")
result = ai_agent.execute_action("create_directory", {"path": path})
if result.get("success"):
logger.info(f"
目录创建成功: {path}")
return jsonify({"success": True, "message": f"
目录 '{path}' 创建成功"})
else:
logger.warning(f"
目录创建失败: {path} - {result.get('message')}")
return jsonify({"error": result.get("message", "
目录创建失败")}), 500
except Exception as e:
logger.error(f"创建
目录失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route('/api/delete_path', methods=['POST'])
def delete_path():
"""删除指定路径（文件或
目录）"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
path = data.get('path')
confirm = data.get('confirm', False)
if not path:
return jsonify({"error": "Missing path parameter"}), 400
if not confirm:
return jsonify({
"warning": "此操作不可逆，请确认",
"confirmation_required": True,
"path": path
}), 202
logger.warning(f"删除路径: {path}")
result = ai_agent.execute_action("delete_path", {"path": path})
if result.get("success"):
logger.info(f"路径删除成功: {path}")
return jsonify({"success": True, "message": f"路径 '{极客}' 删除成功"})
else:
logger.error(f"路径删除失败: {path} - {result.get('message')}")
return jsonify({"error": result.get("message", "路径删除失败")}), 500
except Exception as e:
logger.error(f"删除路径失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route('/api/current_tasks')
def current_tasks():
"""获取当前正在运行的任务列表"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
page = int(request.args.get('page', 1))
per_page = int(request.args.get('per_page', 10))
tasks = ai_agent.get_current_tasks()
total_tasks = len(tasks)
start_index = (page - 1) * per_page
end_index = start_index + per_page
paginated_tasks = tasks[start_index:end_index]
return jsonify({
"tasks": paginated_tasks,
"pagination": {
"page": page,
"per_page": per_page,
"total": total_tasks,
"total_pages": (total_tasks + per_page - 1) // per_page
}
})
except Exception as e:
logger.error(f"获取当前任务失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
# ========== 新增辅助功能 ==========
@app.route('/health')
def health_check():
"""系统健康检查"""
status = {
"status": "ok",
"agent_initialized": bool(ai_agent),
"life_system_initialized": bool(life_scheduler),
"timestamp": time.time(),
"uptime": time.time() - start_time,
"config": {
"version": "1.0",
"environment": config.ENV
}
}
return jsonify(status)
@app.route('/server_info')
def server_info():
"""获取服务器信息"""
import platform
return jsonify({
"python_version": sys.version,
"platform": platform.platform(),
"flask_version": Flask.__version__,
"system_encoding": sys.getdefaultencoding(),
"start_time": start_time,
"config_source": "统一配置加载器",
"config_path": os.path.join(base_dir, 'config'),
"life_system_status": "运行中" if life_scheduler else "未初始化"
})
if __name__ == '__main__':
start_time = time.time()
logger.info("=" * 50)
logger.info(f"🚀 启动Web服务: http://{config.HOST}:{config.PORT}")
logger.info(f"环境: {config.ENV}")
logger.info(f"日志级别: {config.LOG_LEVEL}")
logger.info(f"生活系统: {'✅ 已启用' if life_scheduler else '❌ 未启用'}")
logger.info(f"智能体: {'✅ 已启用' if ai_agent else '❌ 未启用'}")
logger.info("=" * 50)
try:
# 使用配置中的主机和端口
app.run(host=config.HOST, port=config.PORT, threaded=True)
except Exception as e:
logger.critical(f"‼️ 服务器启动失败: {traceback.format_exc()}")
“请把改完的 完整的发我，3. 生活系统初始化失败问题我不知道这个你让我改哪个文件，2. 智能体模块导入失败问题 这个我也不知道你让我改啥
TM2013消息目录自定义教程
本文提供了解决TM2013preview版本中无法自定义消息保存目录的问题方案。通过修改UserDataInfo.ini文件，用户可以指定消息记录保存的位置，避免默认保存在我的文档下导致的同步问题。
扫一扫
4268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
