# FastAPI 相关导入 from fastapi import FastAPI, HTTPException, status, UploadFile, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.responses import JSONResponse, FileResponse, Response from fastapi.staticfiles import StaticFiles # 数据模型和验证相关 from pydantic import BaseModel from typing import Optional, List # 数据库相关 from sqlalchemy import select, func, delete, desc from database import get_session, AccountModel, AccountUsageRecordModel, init_db # 文件和路径处理 from pathlib import Path # 时间处理 from datetime import datetime # 异步和上下文管理 import asyncio from contextlib import asynccontextmanager # 系统和环境相关 import os import traceback import uvicorn from dotenv import load_dotenv # 日志和错误处理 from logger import info, error # 自定义模块 from cursor_pro_keep_alive import main as register_account from tokenManager.cursor import Cursor # 并发和缓存 import concurrent.futures from functools import lru_cache # 配置参数 from config import ( MAX_ACCOUNTS, REGISTRATION_INTERVAL, API_HOST, API_PORT, API_DEBUG, API_WORKERS, ) # 其他工具 import json import time # 全局状态追踪 registration_status = { "is_running": False, "last_run": None, "last_status": None, "next_run": None, "total_runs": 0, "successful_runs": 0, "failed_runs": 0, } # 定义静态文件目录 static_path = Path(__file__).parent / "static" static_path.mkdir(exist_ok=True) # 确保目录存在 # 全局任务存储 background_tasks = {"registration_task": None} # 添加lifespan管理器，在应用启动时初始化数据库 @asynccontextmanager async def lifespan(app: FastAPI): # 启动时初始化数据库 await init_db() info(f'服务已启动! \n 首页地址：http://127.0.0.1:{API_PORT}/') yield # 关闭时的清理操作 info("应用程序已关闭!") app = FastAPI( title="Cursor Account API", description="API for managing Cursor accounts", version="1.0.0", docs_url="/docs", redoc_url="/redoc", lifespan=lifespan, debug=API_DEBUG, ) # 挂载静态文件目录 app.mount("/static", StaticFiles(directory=str(static_path)), name="static") # 添加CORS中间件 app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) class Account(BaseModel): email: str password: Optional[str] = None token: str user: str usage_limit: Optional[str] = None created_at: Optional[str] = None status: str = "active" # 默认为"active" id: Optional[int] = None # 添加id字段，可选 class Config: from_attributes = True class AccountResponse(BaseModel): success: bool data: Optional[Account] = None message: str = "" async def get_active_account_count() -> int: """获取当前账号总数""" async with get_session() as session: result = await session.execute( select(func.count()) .select_from(AccountModel) .where(AccountModel.status == "active") ) return result.scalar() async def get_account_count() -> int: """获取当前账号总数""" async with get_session() as session: result = await session.execute(select(func.count()).select_from(AccountModel)) return result.scalar() async def run_registration(): """运行注册脚本""" global registration_status browser_manager = None try: info("注册任务开始运行") while registration_status["is_running"]: try: count = await get_active_account_count() info(f"当前数据库已激活账号数: {count}") if count >= MAX_ACCOUNTS: # 修改：不再结束任务，而是进入监控模式 info(f"已达到最大账号数量 ({count}/{MAX_ACCOUNTS})，进入监控模式") registration_status["last_status"] = "monitoring" # 等待检测间隔时间 next_check = datetime.now().timestamp() + REGISTRATION_INTERVAL registration_status["next_run"] = next_check info(f"将在 {REGISTRATION_INTERVAL} 秒后重新检查账号数量") await asyncio.sleep(REGISTRATION_INTERVAL) # 跳过当前循环的剩余部分，继续下一次循环检查 continue info(f"开始注册尝试 (当前账号数: {count}/{MAX_ACCOUNTS})") registration_status["last_run"] = datetime.now().isoformat() registration_status["total_runs"] += 1 # 调用注册函数 try: success = await asyncio.get_event_loop().run_in_executor( None, register_account ) if success: registration_status["successful_runs"] += 1 registration_status["last_status"] = "success" info("注册成功") else: registration_status["failed_runs"] += 1 registration_status["last_status"] = "failed" info("注册失败") except SystemExit: # 捕获 SystemExit 异常，这是注册脚本正常退出的方式 info("注册脚本正常退出") if registration_status["last_status"] != "error": registration_status["last_status"] = "completed" except Exception as e: error(f"注册过程执行出错: {str(e)}") error(traceback.format_exc()) registration_status["failed_runs"] += 1 registration_status["last_status"] = "error" # 更新下次运行时间 next_run = datetime.now().timestamp() + REGISTRATION_INTERVAL registration_status["next_run"] = next_run info(f"等待 {REGISTRATION_INTERVAL} 秒后进行下一次尝试") await asyncio.sleep(REGISTRATION_INTERVAL) except asyncio.CancelledError: info("注册迭代被取消") raise except Exception as e: registration_status["failed_runs"] += 1 registration_status["last_status"] = "error" error(f"注册过程出错: {str(e)}") error(traceback.format_exc()) if not registration_status["is_running"]: break await asyncio.sleep(REGISTRATION_INTERVAL) except asyncio.CancelledError: info("注册任务被取消") raise except Exception as e: error(f"注册任务致命错误: {str(e)}") error(traceback.format_exc()) raise finally: registration_status["is_running"] = False if browser_manager: try: browser_manager.quit() except Exception as e: error(f"清理浏览器资源时出错: {str(e)}") error(traceback.format_exc()) @app.get("/", tags=["UI"]) async def serve_index(): """提供Web UI界面""" index_path = Path(__file__).parent / "index.html" return FileResponse(index_path) @app.get("/general", tags=["General"]) async def root(): """API根路径，返回API信息""" try: # 获取当前账号数量和使用情况 async with get_session() as session: result = await session.execute(select(AccountModel)) accounts = result.scalars().all() usage_info = [] total_balance = 0 active_accounts = 0 for acc in accounts: remaining_balance = Cursor.get_remaining_balance(acc.user, acc.token) remaining_days = Cursor.get_trial_remaining_days(acc.user, acc.token) if remaining_balance is not None and remaining_balance > 0: active_accounts += 1 total_balance += remaining_balance usage_info.append( { "email": acc.email, "balance": remaining_balance, "days": remaining_days, "status": ( "active" if remaining_balance is not None and remaining_balance > 0 else "inactive" ), } ) return { "service": { "name": "Cursor Account API", "version": "1.0.0", "status": "running", "description": "API for managing Cursor Pro accounts and automatic registration", }, "statistics": { "total_accounts": len(accounts), "active_accounts": active_accounts, "total_remaining_balance": total_balance, "max_accounts": MAX_ACCOUNTS, "remaining_slots": MAX_ACCOUNTS - len(accounts), "registration_interval": f"{REGISTRATION_INTERVAL} seconds", }, "accounts_info": usage_info, # 添加账号详细信息 "registration_status": { "is_running": registration_status["is_running"], "last_run": registration_status["last_run"], "last_status": registration_status["last_status"], "next_run": registration_status["next_run"], "statistics": { "total_runs": registration_status["total_runs"], "successful_runs": registration_status["successful_runs"], "failed_runs": registration_status["failed_runs"], "success_rate": ( f"{(registration_status['successful_runs'] / registration_status['total_runs'] * 100):.1f}%" if registration_status["total_runs"] > 0 else "N/A" ), }, }, "endpoints": { "documentation": {"swagger": "/docs", "redoc": "/redoc"}, "health": { "check": "/health", "registration_status": "/registration/status", }, "accounts": { "list_all": "/accounts", "random": "/account/random", "create": {"path": "/account", "method": "POST"}, "delete": {"path": "/account/{email}", "method": "DELETE"}, "usage": { "path": "/account/{email}/usage", "method": "GET", "description": "Get account usage by email", }, }, "registration": { "start": {"path": "/registration/start", "method": "GET"}, "stop": {"path": "/registration/stop", "method": "POST"}, "status": {"path": "/registration/status", "method": "GET"}, }, "usage": {"check": {"path": "/usage", "method": "GET"}}, "clean": { "run": { "path": "/clean", "method": "POST", "params": {"clean_type": ["check", "disable", "delete"]}, } }, }, "support": { "github": "https://github.com/Elawen-Carl/cursor-account-api", "author": "Elawen Carl", "contact": "elawencarl@gmail.com", }, "timestamp": datetime.now().isoformat(), } except Exception as e: error(f"根端点错误: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Error fetching API information", ) @app.get("/health", tags=["General"]) async def health_check(): """健康检查端点""" return {"status": "healthy"} @app.get("/accounts", tags=["Accounts"]) async def get_accounts( page: int = 1, per_page: int = 10, search: Optional[str] = None, sort_by: str = "created_at", # 新增排序字段参数 order: str = "desc" # 新增排序方向参数 ): """获取所有账号列表，支持分页、搜索和排序""" try: async with get_session() as session: # 验证排序参数 valid_sort_fields = {"id", "email", "created_at", "usage_limit"} valid_orders = {"asc", "desc"} if sort_by not in valid_sort_fields: sort_by = "created_at" # 默认排序字段 if order not in valid_orders: order = "desc" # 默认排序方向 # 构建基本查询 query = select(AccountModel) # 应用排序 sort_field = getattr(AccountModel, sort_by) if order == "desc": query = query.order_by(desc(sort_field)) else: query = query.order_by(sort_field) # 如果有搜索参数 if search: search = f"%{search}%" query = query.where(AccountModel.email.like(search)) # 计算总记录数 count_query = select(func.count()).select_from(AccountModel) if search: count_query = count_query.where(AccountModel.email.like(search)) total_count = await session.scalar(count_query) # 计算分页 total_pages = (total_count + per_page - 1) // per_page # 向上取整 # 应用分页 query = query.offset((page - 1) * per_page).limit(per_page) # 执行查询 result = await session.execute(query) accounts = result.scalars().all() # 构建分页响应 return { "success": True, "data": accounts, "pagination": { "page": page, "per_page": per_page, "total_count": total_count, "total_pages": total_pages }, "sort": { "field": sort_by, "order": order } } except Exception as e: error(f"获取账号列表失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"获取账号列表失败: {str(e)}", ) @app.get("/account/random", response_model=AccountResponse, tags=["Accounts"]) async def get_random_account(): """随机获取一个可用的账号和token""" try: async with get_session() as session: result = await session.execute( select(AccountModel).order_by(func.random()).limit(1) ) account = result.scalar_one_or_none() if not account: return AccountResponse(success=False, message="No accounts available") return AccountResponse(success=True, data=Account.from_orm(account)) except Exception as e: error(f"获取随机账号失败: {str(e)}") error(traceback.format_exc()) raise HTTPException(status_code=500, detail="Internal server error") @app.post("/account", response_model=AccountResponse, tags=["Accounts"]) async def create_account(account: Account): """创建新账号""" try: async with get_session() as session: db_account = AccountModel( email=account.email, password=account.password, token=account.token, usage_limit=account.usage_limit, created_at=account.created_at, ) session.add(db_account) await session.commit() return AccountResponse( success=True, data=account, message="Account created successfully" ) except Exception as e: error(f"创建账号失败: {str(e)}") error(traceback.format_exc()) return AccountResponse( success=False, message=f"Failed to create account: {str(e)}" ) @app.delete("/account/{email}", response_model=AccountResponse, tags=["Accounts"]) async def delete_account(email: str, hard_delete: bool = False): """删除或停用指定邮箱的账号 如果 hard_delete=True，则物理删除账号 否则仅将状态设置为'deleted' """ try: async with get_session() as session: # 先检查账号是否存在 result = await session.execute( select(AccountModel).where(AccountModel.email == email) ) account = result.scalar_one_or_none() if not account: return AccountResponse(success=False, message=f"账号 {email} 不存在") if hard_delete: # 物理删除账号 await session.execute( delete(AccountModel).where(AccountModel.email == email) ) delete_message = f"账号 {email} 已永久删除" else: # 逻辑删除：将状态更新为'deleted' account.status = "deleted" delete_message = f"账号 {email} 已标记为删除状态" await session.commit() return AccountResponse(success=True, message=delete_message) except Exception as e: error(f"删除账号失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"删除账号失败: {str(e)}", ) # 添加状态更新的请求体模型 class StatusUpdate(BaseModel): status: str @app.put("/account/id/{id}/status", response_model=AccountResponse, tags=["Accounts"]) async def update_account_status(id: str, update: StatusUpdate): """更新账号状态 可选状态: active (正常), disabled (停用), deleted (已删除) """ # 使用update.status替代原先的status参数 try: # 验证状态值 valid_statuses = ["active", "disabled", "deleted"] if update.status not in valid_statuses: return AccountResponse( success=False, message=f"无效的状态值。允许的值: {', '.join(valid_statuses)}", ) async with get_session() as session: # 通过邮箱查询账号 result = await session.execute( select(AccountModel).where(AccountModel.id == id) ) account = result.scalar_one_or_none() if not account: return AccountResponse( success=False, message=f"邮箱为 {email} 的账号不存在" ) # 更新状态 account.status = update.status await session.commit() return AccountResponse( success=True, message=f"账号 {account.email} 状态已更新为 '{update.status}'", ) except Exception as e: error(f"通过邮箱更新账号状态失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"更新账号状态失败: {str(e)}", ) @app.get("/registration/start", tags=["Registration"]) async def start_registration(): """手动启动注册任务""" info("手动启动注册任务") global background_tasks, registration_status try: # 检查是否已达到最大账号数 count = await get_active_account_count() # 检查任务是否已在运行 if ( background_tasks["registration_task"] and not background_tasks["registration_task"].done() ): # 确定当前状态 current_status = ( "monitoring" if registration_status["last_status"] == "monitoring" else "running" ) status_message = ( f"注册任务已在运行中 (状态: {current_status})" if current_status == "running" else f"已达到最大账号数量({count}/{MAX_ACCOUNTS})，正在监控账号状态，当账号数量减少时将自动继续注册" ) info(f"注册请求被忽略 - 任务已在{current_status}状态") return { "success": True, "message": status_message, "status": { "is_running": registration_status["is_running"], "last_run": registration_status["last_run"], "next_run": ( datetime.fromtimestamp( registration_status["next_run"] ).isoformat() if registration_status["next_run"] else None ), "last_status": registration_status["last_status"], "current_count": count, "max_accounts": MAX_ACCOUNTS, }, } # 重置注册状态 registration_status.update( { "is_running": True, "last_status": "starting", "last_run": datetime.now().isoformat(), "next_run": datetime.now().timestamp() + REGISTRATION_INTERVAL, "total_runs": 0, "successful_runs": 0, "failed_runs": 0, } ) # 创建并启动新任务 loop = asyncio.get_running_loop() task = loop.create_task(run_registration()) background_tasks["registration_task"] = task # 添加任务完成回调 def task_done_callback(task): try: task.result() # 这将重新引发任何未处理的异常 except asyncio.CancelledError: info("注册任务被取消") registration_status["last_status"] = "cancelled" except Exception as e: error(f"注册任务失败: {str(e)}") error(traceback.format_exc()) registration_status["last_status"] = "error" finally: if registration_status["is_running"]: # 只有在任务仍在运行时才更新状态 registration_status["is_running"] = False background_tasks["registration_task"] = None task.add_done_callback(task_done_callback) info("手动启动注册任务") # 等待任务实际开始运行 await asyncio.sleep(1) # 检查任务是否成功启动 if task.done(): try: task.result() # 如果任务已完成，检查是否有异常 except Exception as e: error(f"注册任务启动失败: {str(e)}") error(traceback.format_exc()) registration_status["is_running"] = False registration_status["last_status"] = "error" raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to start registration task: {str(e)}", ) # 检查是否已达到最大账号数，预先设置为监控模式 if count >= MAX_ACCOUNTS: registration_status["last_status"] = "monitoring" status_message = f"已达到最大账号数量({count}/{MAX_ACCOUNTS})，进入监控模式，当账号数量减少时将自动继续注册" else: status_message = "注册任务启动成功" return { "success": True, "message": status_message, "status": { "is_running": registration_status["is_running"], "last_run": registration_status["last_run"], "next_run": datetime.fromtimestamp( registration_status["next_run"] ).isoformat(), "last_status": registration_status["last_status"], "current_count": count, "max_accounts": MAX_ACCOUNTS, }, } except Exception as e: error(f"启动注册任务失败: {str(e)}") error(traceback.format_exc()) registration_status["is_running"] = False registration_status["last_status"] = "error" raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to start registration task: {str(e)}", ) @app.get("/registration/stop", tags=["Registration"]) async def stop_registration(): """手动停止注册任务""" global background_tasks try: if ( not background_tasks["registration_task"] or background_tasks["registration_task"].done() ): return {"success": False, "message": "No running registration task found"} background_tasks["registration_task"].cancel() try: await background_tasks["registration_task"] except asyncio.CancelledError: info("注册任务被取消") background_tasks["registration_task"] = None registration_status["is_running"] = False registration_status["last_status"] = "manually stopped" return {"success": True, "message": "Registration task stopped successfully"} except Exception as e: error(f"停止注册任务失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to stop registration task: {str(e)}", ) @app.get("/registration/status", tags=["Registration"]) async def get_registration_status(): """获取注册状态""" try: count = await get_account_count() active_count = await get_active_account_count() # 添加获取活跃账号数 # 更新任务状态逻辑 if ( background_tasks["registration_task"] and not background_tasks["registration_task"].done() ): if registration_status["last_status"] == "monitoring": task_status = "monitoring" # 新增监控状态 else: task_status = "running" else: task_status = "stopped" status_info = { "current_count": count, "active_count": active_count, # 添加活跃账号数 "max_accounts": MAX_ACCOUNTS, "is_registration_active": active_count < MAX_ACCOUNTS, "remaining_slots": MAX_ACCOUNTS - active_count, "task_status": task_status, "registration_details": { "is_running": registration_status["is_running"], "last_run": registration_status["last_run"], "last_status": registration_status["last_status"], "next_run": registration_status["next_run"], "statistics": { "total_runs": registration_status["total_runs"], "successful_runs": registration_status["successful_runs"], "failed_runs": registration_status["failed_runs"], "success_rate": ( f"{(registration_status['successful_runs'] / registration_status['total_runs'] * 100):.1f}%" if registration_status["total_runs"] > 0 else "N/A" ), }, }, } # 添加状态解释信息 if task_status == "monitoring": status_info["status_message"] = ( f"已达到最大账号数量({active_count}/{MAX_ACCOUNTS})，正在监控账号状态，当账号数量减少时将自动继续注册" ) elif task_status == "running": status_info["status_message"] = ( f"正在执行注册流程，当前账号数：{active_count}/{MAX_ACCOUNTS}" ) else: status_info["status_message"] = "注册任务未运行" # info(f"请求注册状态 (当前账号数: {count}, 活跃账号数: {active_count}, 状态: {task_status})") return status_info except Exception as e: error(f"获取注册状态失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to get registration status: {str(e)}", ) # 自定义异常处理 @app.exception_handler(HTTPException) async def http_exception_handler(request, exc): error(f"HTTP错误发生: {exc.detail}") return JSONResponse( status_code=exc.status_code, content={"success": False, "message": exc.detail} ) @app.exception_handler(Exception) async def general_exception_handler(request, exc): error(f"意外错误发生: {str(exc)}") error(f"错误详情: {traceback.format_exc()}") return JSONResponse( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content={ "success": False, "message": "Internal server error occurred", "detail": str(exc) if app.debug else None, }, ) # 添加缓存装饰器 @lru_cache(maxsize=100) def get_account_status(user: str, token: str, timestamp: int): """缓存10分钟内的账号状态""" balance = Cursor.get_remaining_balance(user, token) days = Cursor.get_trial_remaining_days(user, token) return { "balance": balance, "days": days, "status": "active" if balance is not None and balance > 0 else "inactive", } # 修改 check_usage 接口 @app.get("/usage") async def check_usage(): """ 获取所有账号的使用量信息 该接口会并发查询所有账号的余额和剩余天数，并返回汇总信息 使用了缓存机制避免频繁请求API，缓存时间为10分钟 返回: - total_accounts: 总账号数量 - usage_info: 每个账号的详细使用量信息列表 - summary: 账号状态汇总信息，包括活跃账号数、非活跃账号数和总剩余额度 """ try: async with get_session() as session: # 从数据库获取所有账号 result = await session.execute(select(AccountModel)) accounts = result.scalars().all() # 使用当前时间的10分钟间隔作为缓存key # 将时间戳除以600(10分钟)取整，作为缓存标识 cache_timestamp = int(datetime.now().timestamp() / 600) # 使用线程池并发获取账号状态，最多10个并发线程 # 避免串行请求API导致接口响应过慢 with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor: # 为每个账号创建一个异步任务 futures = [ executor.submit( get_account_status, acc.user, acc.token, cache_timestamp ) for acc in accounts ] # 收集每个账号的使用量信息 usage_info = [] for acc, future in zip(accounts, futures): status = future.result() usage_info.append( { "email": acc.email, "usage_limit": status["balance"], # 剩余额度 "remaining_days": status["days"], # 剩余天数 "status": status["status"], # 账号状态 } ) # 返回汇总信息 return { "total_accounts": len(accounts), # 总账号数 "usage_info": usage_info, # 详细使用量信息 "summary": { # 统计活跃账号数量 "active_accounts": sum( 1 for info in usage_info if info["status"] == "active" ), # 统计非活跃账号数量 "inactive_accounts": sum( 1 for info in usage_info if info["status"] == "inactive" ), # 计算所有账号的总剩余额度 "total_remaining_balance": sum( info["usage_limit"] or 0 for info in usage_info ), }, } except Exception as e: # 记录错误日志 error(f"检查使用量失败: {str(e)}") error(traceback.format_exc()) # 抛出HTTP异常 raise HTTPException(status_code=500, detail=str(e)) @app.get("/account/{email}/usage", tags=["Accounts"]) async def get_account_usage(email: str): """根据邮箱查询账户使用量并更新数据库""" try: async with get_session() as session: # 查询指定邮箱的账号 result = await session.execute( select(AccountModel).where(AccountModel.email == email) ) account = result.scalar_one_or_none() if not account: raise HTTPException( status_code=404, detail=f"Account with email {email} not found" ) # 获取账号使用量 remaining_balance = Cursor.get_remaining_balance( account.user, account.token ) remaining_days = Cursor.get_trial_remaining_days( account.user, account.token ) # 计算总额度和已使用额度 total_limit = 150 # 默认总额度 used_limit = 0 if remaining_balance is not None: used_limit = total_limit - remaining_balance if remaining_days is not None and remaining_days == 0: account.status = "disabled" # 更新数据库中的usage_limit字段 account.usage_limit = str(remaining_balance) await session.commit() db_updated = True else: db_updated = False return { "success": True, "email": account.email, "usage": { "remaining_balance": remaining_balance, "total_limit": total_limit, "used_limit": used_limit, "remaining_days": remaining_days, "status": ( "active" if remaining_balance is not None and remaining_balance > 0 else "inactive" ), }, "db_updated": db_updated, "timestamp": datetime.now().isoformat(), } except HTTPException: raise except Exception as e: error(f"查询账号使用量失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"Failed to get account usage: {str(e)}"} # 添加通过ID删除账号的API @app.delete("/account/id/{id}", response_model=AccountResponse, tags=["Accounts"]) async def delete_account_by_id(id: int, hard_delete: bool = False): """通过ID删除或停用账号 如果 hard_delete=True，则物理删除账号 否则仅将状态设置为'deleted' """ try: async with get_session() as session: # 通过ID查询账号 result = await session.execute( select(AccountModel).where(AccountModel.id == id) ) account = result.scalar_one_or_none() if not account: return AccountResponse(success=False, message=f"ID为 {id} 的账号不存在") email = account.email # 保存邮箱以在响应中显示 if hard_delete: # 物理删除账号 await session.execute(delete(AccountModel).where(AccountModel.id == id)) delete_message = f"账号 {email} (ID: {id}) 已永久删除" else: # 逻辑删除：将状态更新为'deleted' account.status = "deleted" delete_message = f"账号 {email} (ID: {id}) 已标记为删除状态" await session.commit() return AccountResponse(success=True, message=delete_message) except Exception as e: error(f"通过ID删除账号失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"删除账号失败: {str(e)}", ) # 添加导出账号列表功能 @app.get("/accounts/export", tags=["Accounts"]) async def export_accounts(): """导出所有账号为JSON文件""" try: async with get_session() as session: query = select(AccountModel).order_by(desc(AccountModel.created_at)) result = await session.execute(query) accounts = result.scalars().all() # 转换为可序列化的数据 accounts_data = [] for account in accounts: account_dict = { "id": account.id, "email": account.email, "password": account.password, "token": account.token, "user": account.user, "usage_limit": account.usage_limit, "created_at": account.created_at, "status": account.status } accounts_data.append(account_dict) # 创建响应 content = json.dumps(accounts_data, ensure_ascii=False, indent=2) response = Response(content=content) response.headers["Content-Disposition"] = "attachment; filename=cursor_accounts.json" response.headers["Content-Type"] = "application/json" return response except Exception as e: error(f"导出账号失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"导出账号失败: {str(e)}", ) # 添加导入账号列表功能 @app.post("/accounts/import", tags=["Accounts"]) async def import_accounts(file: UploadFile): """从JSON文件导入账号""" try: # 读取上传的文件内容 content = await file.read() # 解析JSON数据 try: accounts_data = json.loads(content.decode("utf-8")) except json.JSONDecodeError: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="无效的JSON文件格式", ) # 验证数据结构 if not isinstance(accounts_data, list): raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail="JSON数据必须是账号对象的数组", ) # 导入计数器 imported = 0 updated = 0 skipped = 0 async with get_session() as session: for account_data in accounts_data: # 提取必要字段，提供默认值 email = account_data.get("email") if not email: skipped += 1 continue # 检查账号是否已存在 query = select(AccountModel).where(AccountModel.email == email) result = await session.execute(query) existing_account = result.scalar_one_or_none() if existing_account: # 更新现有账号 existing_account.password = account_data.get("password", existing_account.password) existing_account.token = account_data.get("token", existing_account.token) existing_account.user = account_data.get("user", existing_account.user) existing_account.usage_limit = account_data.get("usage_limit", existing_account.usage_limit) existing_account.status = account_data.get("status", existing_account.status) updated += 1 else: # 创建新账号 new_account = AccountModel( id=account_data.get("id", int(time.time() * 1000)), email=email, password=account_data.get("password", ""), token=account_data.get("token", ""), user=account_data.get("user", ""), usage_limit=account_data.get("usage_limit", ""), created_at=account_data.get("created_at", datetime.now().strftime("%Y-%m-%d %H:%M")), status=account_data.get("status", "active") ) session.add(new_account) imported += 1 # 提交所有更改 await session.commit() return { "success": True, "message": f"导入完成: 新增 {imported} 个账号, 更新 {updated} 个账号, 跳过 {skipped} 个无效记录", } except HTTPException: raise except Exception as e: error(f"导入账号失败: {str(e)}") error(traceback.format_exc()) raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"导入账号失败: {str(e)}", ) # 添加"使用Token"功能 @app.post("/account/use-token/{id}", tags=["Accounts"]) async def use_account_token(id: int, request: Request, reset_machine_id: bool = False): """使用指定账号的Token更新Cursor认证，可选是否重置机器ID""" try: async with get_session() as session: # 通过ID查询账号 result = await session.execute( select(AccountModel).where(AccountModel.id == id) ) account = result.scalar_one_or_none() if not account: return {"success": False, "message": f"ID为 {id} 的账号不存在"} # 调用CursorAuthManager更新认证 from cursor_auth_manager import CursorAuthManager auth_manager = CursorAuthManager() success = auth_manager.update_auth( email=account.email, access_token=account.token, refresh_token=account.token ) # 仅在用户选择时才重置机器ID patch_success = False if reset_machine_id: from cursor_shadow_patcher import CursorShadowPatcher resetter = CursorShadowPatcher() patch_success = resetter.reset_machine_ids() # 更新返回消息 if success and reset_machine_id and patch_success: return { "success": True, "message": f"成功使用账号 {account.email} 的Token并重置了机器ID", } elif success and reset_machine_id and not patch_success: return { "success": True, "message": f"成功使用账号 {account.email} 的Token，但机器ID重置失败", } elif success: return { "success": True, "message": f"成功使用账号 {account.email} 的Token（未重置机器ID）", } else: return {"success": False, "message": "Token更新失败"} except Exception as e: error(f"使用账号Token失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"使用Token失败: {str(e)}"} # 添加获取账号使用记录接口 @app.get("/account/{id}/usage-records", tags=["Accounts"]) async def get_account_usage_records(id: int): """获取指定账号的使用记录""" try: async with get_session() as session: # 通过ID查询账号 result = await session.execute( select(AccountModel).where(AccountModel.id == id) ) account = result.scalar_one_or_none() if not account: return {"success": False, "message": f"ID为 {id} 的账号不存在"} # 查询使用记录 result = await session.execute( select(AccountUsageRecordModel) .where(AccountUsageRecordModel.account_id == id) .order_by(desc(AccountUsageRecordModel.created_at)) ) records = result.scalars().all() # 转换记录为字典列表 records_list = [] for record in records: records_list.append({ "id": record.id, "account_id": record.account_id, "email": record.email, "ip": record.ip, "user_agent": record.user_agent, "created_at": record.created_at }) return { "success": True, "records": records_list } except Exception as e: error(f"获取账号使用记录失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"获取账号使用记录失败: {str(e)}"} # 添加"重置设备id"功能 @app.get("/reset-machine", tags=["System"]) async def reset_machine(): """重置设备id""" try: # 重置Cursor的机器ID from cursor_shadow_patcher import CursorShadowPatcher resetter = CursorShadowPatcher() patch_success = resetter.reset_machine_ids() if patch_success: return { "success": True, "message": f"成功重置了机器ID", } else: return {"success": False, "message": "重置机器ID失败"} except Exception as e: error(f"重置机器ID失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"重置机器ID失败: {str(e)}"} # 添加配置相关模型 class ConfigModel(BaseModel): BROWSER_HEADLESS: bool DYNAMIC_USERAGENT: Optional[bool] = False BROWSER_USER_AGENT: str MAX_ACCOUNTS: int EMAIL_DOMAINS: str EMAIL_USERNAME: str EMAIL_PIN: str BROWSER_PATH: Optional[str] = None CURSOR_PATH: Optional[str] = None USE_PROXY: Optional[bool] = False PROXY_TYPE: Optional[str] = None PROXY_HOST: Optional[str] = None PROXY_PORT: Optional[str] = None PROXY_TIMEOUT: Optional[int] = None PROXY_USERNAME: Optional[str] = None PROXY_PASSWORD: Optional[str] = None EMAIL_CODE_TYPE: str = "AUTO" # 默认值为AUTO # 获取配置端点 @app.get("/config", tags=["Config"]) async def get_config(): """获取当前系统配置""" try: # 重新加载配置以确保获取最新值 load_dotenv() config = { "BROWSER_HEADLESS": os.getenv("BROWSER_HEADLESS", "True").lower() == "true", "BROWSER_USER_AGENT": os.getenv("BROWSER_USER_AGENT", ""), "MAX_ACCOUNTS": int(os.getenv("MAX_ACCOUNTS", "10")), "EMAIL_TYPE": os.getenv("EMAIL_TYPE", "tempemail"), "EMAIL_PROXY_ENABLED": os.getenv("EMAIL_PROXY_ENABLED", "False").lower() == "true", "EMAIL_PROXY_ADDRESS": os.getenv("EMAIL_PROXY_ADDRESS", ""), "EMAIL_API": os.getenv("EMAIL_API", ""), "EMAIL_DOMAINS": os.getenv("EMAIL_DOMAINS", ""), "EMAIL_USERNAME": os.getenv("EMAIL_USERNAME", ""), "EMAIL_DOMAIN": os.getenv("EMAIL_DOMAIN", ""), "EMAIL_PIN": os.getenv("EMAIL_PIN", ""), "EMAIL_CODE_TYPE": os.getenv("EMAIL_CODE_TYPE", "AUTO"), "BROWSER_PATH": os.getenv("BROWSER_PATH", ""), "CURSOR_PATH": os.getenv("CURSOR_PATH", ""), "DYNAMIC_USERAGENT": os.getenv("DYNAMIC_USERAGENT", "False").lower() == "true", # 添加代理配置 "USE_PROXY": os.getenv("USE_PROXY", "False"), "PROXY_TYPE": os.getenv("PROXY_TYPE", "http"), "PROXY_HOST": os.getenv("PROXY_HOST", ""), "PROXY_PORT": os.getenv("PROXY_PORT", ""), "PROXY_TIMEOUT": os.getenv("PROXY_TIMEOUT", "10"), "PROXY_USERNAME": os.getenv("PROXY_USERNAME", ""), "PROXY_PASSWORD": os.getenv("PROXY_PASSWORD", ""), } return {"success": True, "data": config} except Exception as e: error(f"获取配置失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"获取配置失败: {str(e)}"} # 更新配置端点 @app.post("/config", tags=["Config"]) async def update_config(config: ConfigModel): """更新配置""" try: # 获取.env文件路径 env_path = Path(__file__).parent / ".env" # 读取当前.env文件内容 current_lines = [] if env_path.exists(): with open(env_path, "r", encoding="utf-8") as f: current_lines = f.readlines() # 构建配置字典 - 修正：直接使用模型属性而非get方法 config_dict = { "BROWSER_HEADLESS": str(config.BROWSER_HEADLESS), "DYNAMIC_USERAGENT": str(config.DYNAMIC_USERAGENT), "BROWSER_USER_AGENT": config.BROWSER_USER_AGENT, "MAX_ACCOUNTS": str(config.MAX_ACCOUNTS), "EMAIL_DOMAINS": config.EMAIL_DOMAINS, "EMAIL_USERNAME": config.EMAIL_USERNAME, "EMAIL_PIN": config.EMAIL_PIN, "EMAIL_CODE_TYPE": config.EMAIL_CODE_TYPE, # 添加代理配置 "USE_PROXY": str(config.USE_PROXY), "PROXY_TYPE": config.PROXY_TYPE, "PROXY_HOST": config.PROXY_HOST, "PROXY_PORT": config.PROXY_PORT, "PROXY_TIMEOUT": str(config.PROXY_TIMEOUT), "PROXY_USERNAME": config.PROXY_USERNAME, "PROXY_PASSWORD": config.PROXY_PASSWORD, } # 添加可选配置（如果提供） if config.BROWSER_PATH: config_dict["BROWSER_PATH"] = config.BROWSER_PATH if config.CURSOR_PATH: config_dict["CURSOR_PATH"] = config.CURSOR_PATH # 处理现有行或创建新行 updated_lines = [] updated_keys = set() for line in current_lines: line = line.strip() if not line or line.startswith("#"): updated_lines.append(line) continue key, value = line.split("=", 1) if "=" in line else (line, "") key = key.strip() if key in config_dict: updated_lines.append(f"{key}={config_dict[key]}") updated_keys.add(key) else: updated_lines.append(line) # 添加未更新的配置项 for key, value in config_dict.items(): if key not in updated_keys and value: updated_lines.append(f"{key}={value}") # 写入更新后的配置 with open(env_path, "w", encoding="utf-8") as f: f.write("\n".join(updated_lines)) # 重新加载环境变量 load_dotenv(override=True) return {"success": True, "message": "配置已更新"} except Exception as e: error(f"更新配置失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"更新配置失败: {str(e)}"} # 优化重启API功能，解决卡住问题 @app.post("/restart", tags=["System"]) async def restart_service(): """重启应用服务""" try: info("收到重启服务请求") # 使用更简单的重启方法 - 通过reload环境变量触发uvicorn重载 # 1. 修改.env文件，添加/更新一个时间戳，触发热重载 env_path = os.path.join(os.getcwd(), ".env") timestamp = str(int(time.time())) # 读取现有.env文件 if os.path.exists(env_path): with open(env_path, "r", encoding="utf-8") as f: env_lines = f.read().splitlines() else: env_lines = [] # 更新或添加RESTART_TIMESTAMP变量 timestamp_found = False for i, line in enumerate(env_lines): if line.startswith("RESTART_TIMESTAMP="): env_lines[i] = f"RESTART_TIMESTAMP={timestamp}" timestamp_found = True break if not timestamp_found: env_lines.append(f"RESTART_TIMESTAMP={timestamp}") # 写回.env文件 with open(env_path, "w", encoding="utf-8") as f: f.write("\n".join(env_lines)) info(f"已更新重启时间戳: {timestamp}") # 仅提示用户手动刷新页面 return { "success": True, "message": "配置已更新，请手动刷新页面以应用更改。" } except Exception as e: error(f"重启服务失败: {str(e)}") error(traceback.format_exc()) return {"success": False, "message": f"重启服务失败: {str(e)}"} @app.post("/update_all_usage", tags=["Accounts"]) async def update_all_accounts_usage(): """更新所有账户的使用量信息""" try: async with get_session() as session: # 查询所有账号 result = await session.execute(select(AccountModel)) accounts = result.scalars().all() updated_count = 0 error_count = 0 for account in accounts: try: # 获取账号使用量 remaining_balance = Cursor.get_remaining_balance( account.user, account.token ) remaining_days = Cursor.get_trial_remaining_days( account.user, account.token ) # 更新数据库 if remaining_balance is not None: total_limit = 150 # 默认总额度 used_limit = total_limit - remaining_balance if remaining_days is not None and remaining_days == 0: account.status = "disabled" # 更新数据库中的usage_limit字段 account.usage_limit = str(remaining_balance) updated_count += 1 else: error_count += 1 except Exception as e: error_count += 1 logger.error(f"更新账户 {account.email} 失败: {str(e)}") # 提交所有更改 await session.commit() return { "success": True, "message": f"成功更新 {updated_count} 个账户，失败 {error_count} 个" } except Exception as e: logger.error(f"批量更新账户余量失败: {str(e)}") return {"success": False, "message": str(e)} if __name__ == "__main__": uvicorn.run( "api:app", host=API_HOST, port=API_PORT, reload=API_DEBUG, access_log=True, log_level="error", workers=API_WORKERS, loop="asyncio", # Windows下使用默认的asyncio )