# 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(
9;StartupLogger
9;)
temp_logger.setLevel(logging.DEBUG)
console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter(
9;%(asctime)s - %(name)s - %(levelname)s - %(message)s
9;))
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 = [
9;agent
9;, 
9;core
9;, 
9;utils
9;, 
9;config
9;, 
9;cognitive_arch
9;]
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, 
9;agent
9;)
WEB_UI_PATH = os.path.join(base_dir, 
9;web_ui
9;)
MODEL_CACHE_DIR = os.path.join(base_dir, 
9;model_cache
9;)
LOG_DIR = os.path.join(base_dir, 
9;logs
9;)
HOST = 
9;0.0.0.0
9;
PORT = 8000
SECRET_KEY = 
9;temp-secret-key
9;
LOG_LEVEL = 
9;INFO
9;
USE_GPU = False
DEFAULT_MODEL = 
9;minimal-model
9;
ENV = 
9;development
9;
# 生活系统配置
LIFE_SCHEDULE = {
"wake_up": "08:00",
"breakfast": "08:30",
"lunch": "12:30",
"dinner": "1
9: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, 
9;config/config_loader.py
9;)}")
temp_logger.info(f"2. {os.path.join(base_dir, 
9;config/__init__.py
9;)}")
# ========== 配置Flask应用 ==========
app = Flask(__name__,
template_folder=
9;templates
9;,
static_folder=
9;static
9;)
# ========== 安全日志处理 ==========
def safe_log(message):
"""安全处理日志中的Unicode字符"""
try:
return message.encode(
9;utf-8
9;, 
9;ignore
9;).decode(
9;utf-8
9;)
except:
return message.replace(
9;❌
9;, 
9;[ERROR]
9;).replace(
9;⏳
9;, 
9;[WAIT]
9;).replace(
9;‼️
9;, 
9;[CRITICAL]
9;).replace(
9;✅
9;,

9;[OK]
9;).replace(

9;🚀
9;, 
9;[LAUNCH]
9;)
# ========== 正式日志设置 ==========
logger = logging.getLogger(
9;WebServer
9;)
logger.setLevel(getattr(logging, config.LOG_LEVEL.upper(), logging.INFO))
# 日志格式
log_formatter = logging.Formatter(
9;%(asctime)s - %(name)s - %(levelname)s - %(message)s
9;)
# 文件日志处理器
try:
# 确保日志目录存在
os.makedirs(config.LOG_DIR, exist_ok=True)
from logging.handlers import TimedRotatingFileHandler
file_handler = TimedRotatingFileHandler(
os.path.join(config.LOG_DIR, 
9;web_server.log
9;),
when=
9;midnight
9;,
backupCount=30,
encoding=
9;utf-8
9;
)
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(
9;ascii
9;, 
9;ignore
9;).decode(
9;ascii
9;)
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
# 初始化生活系统 - 修复参数传递问题
# 检查LifeScheduler类是否接受参数
import inspect
sig = inspect.signature(LifeScheduler.__init__)
params = sig.parameters
# 根据构造函数参数动态传递参数
if 
9;daily_schedule
9; in params and 
9;log_dir
9; in params:
life_scheduler = LifeScheduler(
daily_schedule=config.LIFE_SCHEDULE,
log_dir=config.LOG_DIR
)
else:
# 如果构造函数不需要参数，则无参初始化
life_scheduler = LifeScheduler()
# 尝试设置属性
if hasattr(life_scheduler, 
9;daily_schedule
9;):
life_scheduler.daily_schedule = config.LIFE_SCHEDULE
if hasattr(life_scheduler, 
9;log_dir
9;):
life_scheduler.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 1
9 <= current_hour < 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_retr
ies = 3
retry_delay = 2 # 秒
for attempt in range(max_retr
ies):
try:
# 动态导入智能体模块 - 修复导入路径
# 确保agent包中有__init__.py文件
import agent
# 尝试从agent包导入
from agent.autonomous_agent import AutonomousAgent
# 确保模型缓存目录存在
os.makedirs(config.MODEL_CACHE_DIR, exist_ok=True)
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:
# 尝试直接导入模块
try:
from 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
ie2:
logger.error(f"❌ 智能体模块导入
失败: {str(
ie2)}")
if attempt < max_retr
ies - 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_retr
ies}): {str(e)}")
if attempt < max_retr
ies - 1:
logger.info(f"⏳ {retry_delay}秒后重试...")
time.sleep(retry_delay)
else:
logger.critical("‼️ 智能体初始化彻底
失败，部分功能将不可用")
ai_agent = None
# ========== 生活系统路由 ==========
@app.route(
9;/life
9;)
def life_dashboard():
"""生活状态仪表盘页面"""
return render_template(
9;life_dashboard.html
9;)
@app.route(
9;/api/life/status
9;)
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_activit
ies = life_scheduler.get_recent_activit
ies(10)
return jsonify({
"success": True,
"current_activity": current_state["current_activity"],
"next_scheduled": current_state["next_scheduled"],
"schedule": schedule,
"recent_activit
ies": recent_activit
ies
})
except Exception as e:
logger.error(f"获取生活状态
失败: {traceback.format_exc()}")
return jsonify({
"success": False,
"error": str(e)
}), 500
@app.route(
9;/adjust_schedule
9;, methods=[
9;POST
9;])
def adjust_schedule():
"""调整生活计划表"""
if not life_scheduler:
return jsonify({
"success": False,
"error": "生活系统未初始化"
}), 503
try:
data = request.json
adjustments = data.get("adjustments", {})
# 验证调整数据
valid_activit
ies = ["wake_up", "breakfast", "lunch", "dinner", "sleep"]
for activity, new_time in adjustments.items():
if activity not in valid_activit
ies:
raise ValueError(f"无效的活动类型: {activity}")
# 验证时间格式 (HH:MM)
if not isinstance(new_time, str) or len(new_time) != 5 or new_time[2] != 
9;:
9;:
raise ValueError(f"无效的时间格式: {new_time}")
# 应用调整
life_scheduler.adjust_schedule(adjustments)
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(
9;/
9;)
def index():
"""首页路由 - 渲染前端界面"""
return render_template(
9;agent_interface.html
9;)
@app.route(
9;/static/<path:filename>
9;)
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(
9;/status
9;)
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(
9;/chat
9;, methods=[
9;POST
9;])
def chat():
"""处理聊天请求，支持流式响应"""
if ai_agent is None:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
user_input = data.get(
9;message
9;, 
9;
9;)
user_id = data.get(
9;user_id
9;, 
9;default
9;)
stream = data.get(
9;stream
9;, 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({
9;chunk
9;: chunk, 
9;final
9;: is_final})
y
ield f"data: {event_data}\n\n"
response_gen = ai_agent.process_input_stream(user_input, user_id, stream_callback)
for chunk in response_gen:
y
ield chunk
except Exception as e:
logger.error(f"流式响应生成
失败: {traceback.format_exc()}")
y
ield "data: {\"error\": \"流式响应中断\"}\n\n"
y
ield "data: {\"final\": true}\n\n"
return Response(generate(), mimetype=
9;text/event-stream
9;)
except Exception as e:
logger.error(f"聊天处理
失败: {traceback.format_exc()}")
return jsonify({"error": "聊天处理
失败", "details": str(e)}), 500
@app.route(
9;/shutdown
9;, methods=[
9;POST
9;])
def shutdown():
"""处理关机请求"""
try:
data = request.get_json()
delay = data.get(
9;delay
9;, 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(
9;/environment
9;)
def environment_v
iew():
"""渲染环境浏览器界面"""
return render_template(
9;environment_v
iew.html
9;)
@app.route(
9;/api/explore
9;, methods=[
9;GET
9;])
def explore_directory():
"""获取指定路径的目录内容"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
path = request.args.get(
9;path
9;, 
9;
9;)
logger.info(f"探索目录: {path}")
if not path:
workspace_info = ai_agent.get_status().get(
9;environment
9;, {})
if workspace_info and 
9;workspace
9; in workspace_info:
path = workspace_info[
9;workspace
9;]
# 使用智能体的安全路径检查方法
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(
9;/api/furniture
9;)
def get_furniture():
"""获取指定房间的家具数据"""
try:
room = request.args.get(
9;room
9;, 
9;workshop
9;)
logger.info(f"获取家具数据: 房间={room}")
current_time = time.time()
if room in furniture_cache and current_time - furniture_cache[room][
9;timestamp
9;] < CACHE_DURATION:
logger.debug(f"使用缓存家具数据: {room}")
return jsonify(furniture_cache[room][
9;data
9;])
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}, "rotation": {"x": 0, "y": 180, "z": 0}},
{"type": "coffee_table", "position": {"x": 0, "y": -1.5, "z": -3},
"rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "tv", "position": {"x": 0, "y": 0.5, "z": -4}, "rotation": {"x": 0, "y": 0, "z": 0}}
],
"library": [
{"type": "bookshelf", "position": {"x": -3, "y": 0, "z": -3}, "rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "bookshelf", "position": {"x": 0, "y": 0, "z": -3}, "rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "bookshelf", "position": {"x": 3, "y": 0, "z": -3}, "rotation": {"x": 0, "y": 0, "z": 0}},
{"type": "reading_chair", "position": {"x": 0, "y": -1.5, "z": -1},
"rotation": {"x": 0, "y": 180, "z": 0}}
]
}
response_data = {
"room": room,
"items": furniture_data.get(room, [])
}
furniture_cache[room] = {

9;data
9;: response_data,

9;timestamp
9;: current_time
}
return jsonify(response_data)
except Exception as e:
logger.error(f"获取家具数据
失败: {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route(
9;/api/skins
9;)
def get_skins():
"""获取可用皮肤列表"""
try:
skins = [
{"id": "default", "name": "默认皮肤", "description": "简洁的蓝色主题", "version": "1.0"},
{"id": "midnight", "name": "午夜黑", "description": "深色主题，减少眼睛疲劳", "version": "1.2"},
{"id": "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(
9;/api/change_skin
9;, methods=[
9;POST
9;])
def change_skin():
"""更换智能体皮肤"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
skin_name = data.get(
9;skin
9;)
if not skin_name:
return jsonify({"error": "Missing skin parameter"}), 400
skins_response = get_skins().get_json()
skin_ids = [skin[
9;id
9;] for skin in skins_response[
9;skins
9;]]
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(
9;message
9;)}")
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 = [
9;create_directory
9;, 
9;delete_path
9;, 
9;move_file
9;, 
9;copy_file
9;, 
9;execute_command
9;]
@app.route(
9;/api/execute
9;, methods=[
9;POST
9;])
def execute_action():
"""执行环境动作"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
action = data.get(
9;action
9;)
params = data.get(
9;parameters
9;, {})
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(
9;message
9;)}")
return jsonify(result)
except Exception as e:
logger.error(f"动作执行
失败: {action} - {traceback.format_exc()}")
return jsonify({"error": str(e)}), 500
@app.route(
9;/api/environment_status
9;)
def environment_status():
"""获取环境状态信息"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
status = ai_agent.get_status()
env_status = status.get(
9;environment
9;, {})
history = ai_agent.environment.get_exploration_history()
available_actions = ai_agent.get_available_actions()
import psutil
env_status[
9;performance
9;] = {
"cpu_usage": psutil.cpu_percent(),
"memory_usage": psutil.virtual_memory().percent,
"disk_usage": psutil.disk_usage(
9;/
9;).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(
9;/api/agent_status
9;)
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[
9;status
9;] == 
9;pending
9;),
"running": sum(1 for t in task_queue if t[
9;status
9;] == 
9;running
9;),
"completed": sum(1 for t in task_queue if t[
9;status
9;] == 
9;completed
9;),
"failed": sum(1 for t in task_queue if t[
9;status
9;] == 
9;failed
9;)
}
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(
9;/api/create_directory
9;, methods=[
9;POST
9;])
def create_directory():
"""在指定路径创建新目录"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
path = data.get(
9;path
9;)
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"目录 
9;{path}
9; 创建成功"})
else:
logger.warning(f"目录创建
失败: {path} - {result.get(
9;message
9;)}")
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(
9;/api/delete_path
9;, methods=[
9;POST
9;])
def delete_path():
"""删除指定路径（文件或目录）"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
data = request.get_json()
path = data.get(
9;path
9;)
confirm = data.get(
9;confirm
9;, 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"路径 
9;{path}
9; 删除成功"})
else:
logger.error(f"路径删除
失败: {path} - {result.get(
9;message
9;)}")
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(
9;/api/current_tasks
9;)
def current_tasks():
"""获取当前正在运行的任务列表"""
if not ai_agent:
return jsonify({"error": "Agent not initialized"}), 503
try:
page = int(request.args.get(
9;page
9;, 1))
per_page = int(request.args.get(
9;per_page
9;, 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(
9;/health
9;)
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(
9;/server_info
9;)
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, 
9;config
9;),
"life_system_status": "运行中" if life_scheduler else "未初始化"
})
if __name__ == 
9;__main__
9;:
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"生活系统: {
9;✅ 已启用
9; if life_scheduler else 
9;❌ 未启用
9;}")
logger.info(f"智能体: {
9;✅ 已启用
9; if ai_agent else 
9;❌ 未启用
9;}")
logger.info("=" * 50)
try:
# 使用配置中的主机和端口
app.run(host=config.HOST, port=config.PORT, threaded=True)
except Exception as e:
logger.critical(f"‼️ 服务器启动
失败: {traceback.format_exc()}")
修好了 也发我全文哈 辛苦啦
本文分析了一个特定的网站登录问题，在IE9浏览器中由于提交按钮缺少名称属性导致TryUpdateModel返回错误。通过对比不同浏览器的行为，发现IE9会将无名按钮作为参数一并提交，从而引发异常。
扫一扫
1989
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
