Upload 76 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+wiki/img/files.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/settings.png filter=lfs diff=lfs merge=lfs -text
+wiki/img/spaces.png filter=lfs diff=lfs merge=lfs -text

.github/workflows/main.yml

@@ -0,0 +1,56 @@
+on:
+  schedule:
+    - cron: '0 * * * *'
+  workflow_dispatch:     # 支持手动触发
+
+jobs:
+  build-release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Install GitHub CLI
+      run: |
+        sudo apt update && sudo apt install -y curl
+        curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
+        echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+        sudo apt update && sudo apt install -y gh
+
+    - name: Get version
+      id: version
+      run: |
+        VERSION=$(grep 'version=' version.txt | cut -d'=' -f2)
+        echo "version=${VERSION}" >> $GITHUB_OUTPUT
+
+    - name: Add build timestamp
+      run: date +%s > app/build_timestamp.txt
+
+    - name: Create app.zip (flat structure)
+      run: |
+        cd app && zip -r ../app.zip .  # 使用`.`打包当前目录所有文件，不包含父目录
+
+    - name: Create release bundle
+      run: |
+        RELEASE_ZIP="hajimi-${{ steps.version.outputs.version }}.zip"
+        zip $RELEASE_ZIP app.zip Dockerfile requirements.txt version.txt
+        echo "RELEASE_ZIP=${RELEASE_ZIP}" >> $GITHUB_ENV
+
+    - name: Cleanup existing release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        if gh release view "${{ steps.version.outputs.version }}"; then
+          gh release delete "${{ steps.version.outputs.version }}" --yes
+        fi
+
+    - name: Create new release
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      run: |
+        gh release create "${{ steps.version.outputs.version }}" \
+          --title "hajimi-${{ steps.version.outputs.version }}" \
+          "${{ env.RELEASE_ZIP }}"

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# 安装 unzip 工具
+RUN apt-get update && apt-get install -y unzip && rm -rf /var/lib/apt/lists/*
+
+COPY app.zip .
+COPY requirements.txt .
+COPY version.txt .
+RUN mkdir -p app
+# 解压 app.zip 文件
+RUN unzip app.zip -d app && rm app.zip
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 环境变量 (在 Hugging Face Spaces 中设置)
+# ENV GEMINI_API_KEYS=your_key_1,your_key_2,your_key_3
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Dockerfile_git

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY ./app /app/app
+COPY requirements.txt .
+COPY version.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 环境变量 (在 Hugging Face Spaces 中设置)
+# ENV GEMINI_API_KEYS=your_key_1,your_key_2,your_key_3
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/__init__.py

@@ -0,0 +1,9 @@
+from app.api.routes import router, init_router
+from app.api.dashboard import dashboard_router, init_dashboard_router
+
+__all__ = [
+    'router',
+    'init_router',
+    'dashboard_router',
+    'init_dashboard_router'
+]

app/api/auth.py

@@ -0,0 +1,14 @@
+from fastapi import HTTPException, Request
+
+# 密码验证依赖
+async def verify_password(request: Request, PASSWORD: str = None):
+    """验证请求中的Bearer令牌是否与配置的密码匹配"""
+    if PASSWORD:
+        auth_header = request.headers.get("Authorization")
+        if not auth_header or not auth_header.startswith("Bearer "):
+            raise HTTPException(
+                status_code=401, detail="Unauthorized: Missing or invalid token")
+        token = auth_header.split(" ")[1]
+        if token != PASSWORD:
+            raise HTTPException(
+                status_code=401, detail="Unauthorized: Invalid token")

app/api/client_disconnect.py

@@ -0,0 +1,120 @@
+import asyncio
+import time
+from fastapi import Request
+from app.models import ChatCompletionRequest
+from app.utils import create_error_response
+from app.utils.logging import log
+
+# 客户端断开检测函数
+async def check_client_disconnect(http_request: Request, current_api_key: str, request_type: str, model: str):
+    """检查客户端是否断开连接"""
+    while True:
+        if await http_request.is_disconnected():
+            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': model, 'error_message': '检测到客户端断开连接'}
+            log('info', "客户端连接已中断，等待API请求完成", extra=extra_log)
+            return True
+        await asyncio.sleep(0.5)
+
+# 客户端断开处理函数
+async def handle_client_disconnect(
+    gemini_task: asyncio.Task, 
+    chat_request: ChatCompletionRequest, 
+    request_type: str, 
+    current_api_key: str,
+    response_cache_manager,
+    cache_key: str = None,
+    client_ip: str = None
+):
+    try:
+        # 等待API任务完成，使用shield防止它被取消
+        response_content = await asyncio.shield(gemini_task)
+        
+        # 检查响应文本是否为空
+        if response_content is None or response_content.text == "":
+            if response_content is None:
+                log('info', "客户端断开后API任务返回None", 
+                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+            else:
+                extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'status_code': 204}
+                log('info', "客户端断开后Gemini API 返回空响应", extra=extra_log)
+            
+            # 删除任何现有缓存，因为响应为空
+            if cache_key and cache_key in response_cache_manager.cache:
+                log('info', f"因空响应，删除缓存: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'remove-on-empty', 'request_type': request_type})
+                del response_cache_manager.cache[cache_key]
+                
+            # 返回错误响应而不是None
+            return create_error_response(chat_request.model, "AI未返回任何内容，请重试")
+        
+        # 首先检查是否有现有缓存
+        cached_response, cache_hit = response_cache_manager.get(cache_key)
+        if cache_hit:
+            log('info', f"客户端断开但找到已存在缓存，将删除: {cache_key[:8]}...", 
+                extra={'cache_operation': 'disconnect-found-cache', 'request_type': request_type})
+            
+            # 安全删除缓存
+            if cache_key in response_cache_manager.cache:
+                del response_cache_manager.cache[cache_key]
+            
+            # 不返回缓存，而是创建新响应并缓存
+        
+        # 创建新响应
+        from app.utils.response import create_response
+        response = create_response(chat_request, response_content)
+        
+        # 客户端已断开，此响应不会实际发送，可以考虑将其缓存以供后续使用
+        # 如果确实需要缓存，则可以取消下面的注释
+        # cache_response(response, cache_key, client_ip)
+        
+        return response
+    except asyncio.CancelledError:
+        # 对于取消异常，仍然尝试继续完成任务
+        log('info', "客户端断开后任务被取消，但我们仍会尝试完成", 
+            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+        
+        # 检查任务是否已经完成
+        if gemini_task.done() and not gemini_task.cancelled():
+            try:
+                response_content = gemini_task.result()
+                
+                # 首先检查是否有现有缓存
+                cached_response, cache_hit = response_cache_manager.get(cache_key)
+                if cache_hit:
+                    log('info', f"任务被取消但找到已存在缓存，将删除: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'cancel-found-cache', 'request_type': request_type})
+                    
+                    # 安全删除缓存
+                    if cache_key in response_cache_manager.cache:
+                        del response_cache_manager.cache[cache_key]
+                
+                # 创建但不缓存响应
+                from app.utils.response import create_response
+                response = create_response(chat_request, response_content)
+                return response
+            except Exception as inner_e:
+                log('error', f"客户端断开后从已完成任务获取结果失败: {str(inner_e)}", 
+                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+                
+                # 删除缓存，因为出现错误
+                if cache_key and cache_key in response_cache_manager.cache:
+                    log('info', f"因任务获取结果失败，删除缓存: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
+                    del response_cache_manager.cache[cache_key]
+        
+        # 创建错误响应而不是返回None
+        return create_error_response(chat_request.model, "请求处理过程中发生错误，请重试")
+    except Exception as e:
+        # 处理API任务异常
+        error_msg = str(e)
+        extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': error_msg}
+        log('error', f"客户端断开后处理API响应时出错: {error_msg}", extra=extra_log)
+        
+        # 删除缓存，因为出现错误
+        if cache_key and cache_key in response_cache_manager.cache:
+            log('info', f"因API响应错误，删除缓存: {cache_key[:8]}...", 
+                extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
+            del response_cache_manager.cache[cache_key]
+            
+        # 创建错误响应而不是返回None
+        return create_error_response(chat_request.model, f"请求处理错误: {error_msg}")

app/api/dashboard.py

@@ -0,0 +1,182 @@
+from fastapi import APIRouter
+from datetime import datetime, timedelta
+import time
+from app.utils import (
+    log_manager,
+    ResponseCacheManager,
+    ActiveRequestsManager,
+    clean_expired_stats
+)
+from app.config.settings import (
+    api_call_stats,
+    client_request_history,
+    API_KEY_DAILY_LIMIT,
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL,
+    RANDOM_STRING,
+    RANDOM_STRING_LENGTH,
+    MAX_REQUESTS_PER_MINUTE,
+    MAX_REQUESTS_PER_DAY_PER_IP,
+    CACHE_EXPIRY_TIME,
+    MAX_CACHE_ENTRIES,
+    REMOVE_CACHE_AFTER_USE,
+    ENABLE_RECONNECT_DETECTION,
+    version
+)
+from app.services import GeminiClient
+
+# 创建路由器
+dashboard_router = APIRouter(prefix="/api", tags=["dashboard"])
+
+# 全局变量引用，将在init_dashboard_router中设置
+key_manager = None
+response_cache_manager = None
+active_requests_manager = None
+
+def init_dashboard_router(
+    key_mgr,
+    cache_mgr,
+    active_req_mgr
+):
+    """初始化仪表盘路由器"""
+    global key_manager, response_cache_manager, active_requests_manager
+    key_manager = key_mgr
+    response_cache_manager = cache_mgr
+    active_requests_manager = active_req_mgr
+    return dashboard_router
+
+@dashboard_router.get("/dashboard-data")
+async def get_dashboard_data():
+    """获取仪表盘数据的API端点，用于动态刷新"""
+    # 先清理过期数据，确保统计数据是最新的
+    clean_expired_stats(api_call_stats)
+    response_cache_manager.clean_expired()  # 使用管理器清理缓存
+    active_requests_manager.clean_completed()  # 使用管理器清理活跃请求
+    
+    # 获取当前统计数据
+    now = datetime.now()
+    
+    # 计算过去24小时的调用总数
+    last_24h_calls = sum(api_call_stats['last_24h']['total'].values())
+    
+    # 计算过去一小时内的调用总数
+    one_hour_ago = now - timedelta(hours=1)
+    hourly_calls = 0
+    for hour_key, count in api_call_stats['hourly']['total'].items():
+        try:
+            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+            if hour_time >= one_hour_ago:
+                hourly_calls += count
+        except ValueError:
+            continue
+    
+    # 计算过去一分钟内的调用总数
+    one_minute_ago = now - timedelta(minutes=1)
+    minute_calls = 0
+    for minute_key, count in api_call_stats['minute']['total'].items():
+        try:
+            minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
+            if minute_time >= one_minute_ago:
+                minute_calls += count
+        except ValueError:
+            continue
+    
+    # 获取API密钥使用统计
+    api_key_stats = []
+    for api_key in key_manager.api_keys:
+        # 获取API密钥前8位作为标识
+        api_key_id = api_key[:8]
+        
+        # 计算24小时内的调用次数和按模型分类的调用次数
+        calls_24h = 0
+        model_stats = {}
+        
+        if 'by_endpoint' in api_call_stats['last_24h'] and api_key in api_call_stats['last_24h']['by_endpoint']:
+            # 遍历所有模型
+            for model, model_data in api_call_stats['last_24h']['by_endpoint'][api_key].items():
+                model_calls = sum(model_data.values())
+                calls_24h += model_calls
+                model_stats[model] = model_calls
+        
+        # 计算使用百分比
+        usage_percent = (calls_24h / API_KEY_DAILY_LIMIT) * 100 if API_KEY_DAILY_LIMIT > 0 else 0
+        
+        # 添加到结果列表
+        api_key_stats.append({
+            'api_key': api_key_id,
+            'calls_24h': calls_24h,
+            'limit': API_KEY_DAILY_LIMIT,
+            'usage_percent': round(usage_percent, 2),
+            'model_stats': model_stats  # 添加按模型分类的统计数据
+        })
+    
+    # 按使用百分比降序排序
+    api_key_stats.sort(key=lambda x: x['usage_percent'], reverse=True)
+    
+    # 获取最近的日志
+    recent_logs = log_manager.get_recent_logs(500)  # 获取最近500条日志
+    
+    # 获取缓存统计
+    total_cache = len(response_cache_manager.cache)
+    valid_cache = sum(1 for _, data in response_cache_manager.cache.items()
+                     if time.time() < data.get('expiry_time', 0))
+    cache_by_model = {}
+    
+    # 分析缓存数据
+    for _, cache_data in response_cache_manager.cache.items():
+        if time.time() < cache_data.get('expiry_time', 0):
+            # 按模型统计缓存
+            model = cache_data.get('response', {}).model
+            if model:
+                if model in cache_by_model:
+                    cache_by_model[model] += 1
+                else:
+                    cache_by_model[model] = 1
+    
+    # 获取请求历史统计
+    history_count = len(client_request_history)
+    
+    # 获取活跃请求统计
+    active_count = len(active_requests_manager.active_requests)
+    active_done = sum(1 for task in active_requests_manager.active_requests.values() if task.done())
+    active_pending = active_count - active_done
+    
+    # 返回JSON格式的数据
+    return {
+        "key_count": len(key_manager.api_keys),
+        "model_count": len(GeminiClient.AVAILABLE_MODELS),
+        "retry_count": len(key_manager.api_keys),
+        "last_24h_calls": last_24h_calls,
+        "hourly_calls": hourly_calls,
+        "minute_calls": minute_calls,
+        "current_time": datetime.now().strftime('%H:%M:%S'),
+        "logs": recent_logs,
+        "api_key_stats": api_key_stats,
+        # 添加配置信息
+        "max_requests_per_minute": MAX_REQUESTS_PER_MINUTE,
+        "max_requests_per_day_per_ip": MAX_REQUESTS_PER_DAY_PER_IP,
+        # 添加版本信息
+        "local_version": version["local_version"],
+        "remote_version": version["remote_version"],
+        "has_update": version["has_update"],
+        # 添加流式响应配置
+        "fake_streaming": FAKE_STREAMING,
+        "fake_streaming_interval": FAKE_STREAMING_INTERVAL,
+        # 添加随机字符串配置
+        "random_string": RANDOM_STRING,
+        "random_string_length": RANDOM_STRING_LENGTH,
+        # 添加缓存信息
+        "cache_entries": total_cache,
+        "valid_cache": valid_cache,
+        "expired_cache": total_cache - valid_cache,
+        "cache_expiry_time": CACHE_EXPIRY_TIME,
+        "max_cache_entries": MAX_CACHE_ENTRIES,
+        "cache_by_model": cache_by_model,
+        "request_history_count": history_count,
+        "enable_reconnect_detection": ENABLE_RECONNECT_DETECTION,
+        "remove_cache_after_use": REMOVE_CACHE_AFTER_USE,
+        # 添加活跃请求池信息
+        "active_count": active_count,
+        "active_done": active_done,
+        "active_pending": active_pending
+    }

app/api/gemini_handlers.py

@@ -0,0 +1,59 @@
+import asyncio
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils.logging import log
+
+# Gemini完成请求函数
+async def run_gemini_completion(
+    gemini_client, 
+    chat_request: ChatCompletionRequest, 
+    contents,
+    system_instruction,
+    request_type: str,
+    current_api_key: str,
+    safety_settings,
+    safety_settings_g2
+):
+    """运行Gemini非流式请求"""
+    # 记录函数调用状态
+    run_fn = run_gemini_completion
+    
+    try:
+        # 创建一个不会被客户端断开影响的任务
+        response_future = asyncio.create_task(
+            asyncio.to_thread(
+                gemini_client.complete_chat, 
+                chat_request, 
+                contents, 
+                safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings, 
+                system_instruction
+            )
+        )
+        
+        # 使用shield防止任务被外部取消
+        response_content = await asyncio.shield(response_future)
+        
+        # 只在第一次调用时记录完成日志
+        if not hasattr(run_fn, 'logged_complete'):
+            log('info', "非流式请求成功完成", 
+                extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+            run_fn.logged_complete = True
+        return response_content
+    except asyncio.CancelledError:
+        # 即使任务被取消，我们也确保正在进行的API请求能够完成
+        if 'response_future' in locals() and not response_future.done():
+            try:
+                # 使用shield确保任务不被取消，并等待它完成
+                response_content = await asyncio.shield(response_future)
+                log('info', "API请求在客户端断开后完成", 
+                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+                return response_content
+            except Exception as e:
+                log('info', "API调用因客户端断开而失败", 
+                    extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': f'API请求在客户端断开后失败: {str(e)}'})
+                raise
+        
+        # 如果任务尚未开始或已经失败，记录日志
+        log('info', "API调用因客户端断开而取消", 
+            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message': '客户端断开导致API调用取消'})
+        raise

app/api/nonstream_handlers.py

@@ -0,0 +1,157 @@
+import asyncio
+from fastapi import HTTPException, status, Request
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import cache_response, update_api_call_stats
+from app.utils.logging import log
+from .client_disconnect import check_client_disconnect, handle_client_disconnect
+from .gemini_handlers import run_gemini_completion
+
+# 非流式请求处理函数
+async def process_nonstream_request(
+    chat_request: ChatCompletionRequest, 
+    http_request: Request, 
+    request_type: str,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    response_cache_manager,
+    active_requests_manager,
+    safety_settings,
+    safety_settings_g2,
+    api_call_stats,
+    cache_key: str = None,
+    client_ip: str = None
+):
+    """处理非流式API请求"""
+    gemini_client = GeminiClient(current_api_key)
+    
+    # 创建任务
+    gemini_task = asyncio.create_task(
+        run_gemini_completion(
+            gemini_client,
+            chat_request,
+            contents,
+            system_instruction,
+            request_type,
+            current_api_key,
+            safety_settings,
+            safety_settings_g2
+        )
+    )
+    
+    disconnect_task = asyncio.create_task(
+        check_client_disconnect(
+            http_request,
+            current_api_key,
+            request_type,
+            chat_request.model
+        )
+    )
+
+    try:
+        # 先等待看是否API任务先完成，或者客户端先断开连接
+        done, pending = await asyncio.wait(
+            [gemini_task, disconnect_task],
+            return_when=asyncio.FIRST_COMPLETED
+        )
+
+        if disconnect_task in done:
+            # 客户端已断开连接，但我们仍继续完成API请求以便缓存结果
+            return await handle_client_disconnect(
+                gemini_task,
+                chat_request,
+                request_type,
+                current_api_key,
+                response_cache_manager,
+                cache_key,
+                client_ip
+            )
+        else:
+            # API任务先完成，取消断开检测任务
+            disconnect_task.cancel()
+            
+            # 获取响应内容
+            response_content = await gemini_task
+            
+            # 检查缓存是否已经存在，如果存在则不再创建新缓存
+            cached_response, cache_hit = response_cache_manager.get(cache_key)
+            if cache_hit:
+                log('info', f"缓存已存在，直接返回: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'use-existing', 'request_type': request_type})
+                
+                # 安全删除缓存
+                if cache_key in response_cache_manager.cache:
+                    del response_cache_manager.cache[cache_key]
+                    log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'used-and-removed', 'request_type': request_type})
+                
+                return cached_response
+            
+            # 创建响应
+            from app.utils.response import create_response
+            response = create_response(chat_request, response_content)
+            
+            # 缓存响应
+            cache_response(response, cache_key, client_ip, response_cache_manager, update_api_call_stats, endpoint=current_api_key,model=chat_request.model)
+            
+            # 立即删除缓存，确保只能使用一次
+            if cache_key and cache_key in response_cache_manager.cache:
+                del response_cache_manager.cache[cache_key]
+                log('info', f"缓存创建后立即删除: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'store-and-remove', 'request_type': request_type})
+            
+            # 返回响应
+            return response
+
+    except asyncio.CancelledError:
+        extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 'error_message':"请求被取消"}
+        log('info', "请求取消", extra=extra_log)
+        
+        # 在请求被取消时先检查缓存中是否已有结果
+        cached_response, cache_hit = response_cache_manager.get(cache_key)
+        if cache_hit:
+            log('info', f"请求取消但找到有效缓存，使用缓存响应: {cache_key[:8]}...", 
+                extra={'cache_operation': 'use-cache-on-cancel', 'request_type': request_type})
+            
+            # 安全删除缓存
+            if cache_key in response_cache_manager.cache:
+                del response_cache_manager.cache[cache_key]
+                log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
+                    extra={'cache_operation': 'used-and-removed', 'request_type': request_type})
+            
+            return cached_response
+            
+        # 尝试完成正在进行的API请求
+        if not gemini_task.done():
+            log('info', "请求取消但API请求尚未完成，继续等待...", 
+                extra={'key': current_api_key[:8], 'request_type': request_type})
+            
+            # 使用shield确保任务不会被取消
+            response_content = await asyncio.shield(gemini_task)
+            
+            # 创建响应
+            from app.utils.response import create_response
+            response = create_response(chat_request, response_content)
+            
+            # 不缓存这个响应，直接返回
+            return response
+        else:
+            # 任务已完成，获取结果
+            response_content = gemini_task.result()
+            
+            # 创建响应
+            from app.utils.response import create_response
+            response = create_response(chat_request, response_content)
+            
+            # 不缓存这个响应，直接返回
+            return response
+
+    except HTTPException as e:
+        if e.status_code == status.HTTP_408_REQUEST_TIMEOUT:
+            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model, 
+                        'status_code': 408, 'error_message': '客户端连接中断'}
+            log('error', "客户端连接中断，终止后续重试", extra=extra_log)
+            raise  
+        else:
+            raise

app/api/request_handlers.py

@@ -0,0 +1,154 @@
+import asyncio
+import json
+from typing import Literal
+from fastapi import HTTPException, Request, status
+from fastapi.responses import StreamingResponse
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import protect_from_abuse, handle_gemini_error, handle_api_error
+from app.utils.logging import log
+from .stream_handlers import process_stream_request
+from .nonstream_handlers import process_nonstream_request
+
+# 请求处理函数
+async def process_request(
+    chat_request: ChatCompletionRequest, 
+    http_request: Request, 
+    request_type: Literal['stream', 'non-stream'], 
+    key_manager,
+    response_cache_manager,
+    active_requests_manager,
+    safety_settings,
+    safety_settings_g2,
+    api_call_stats,
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL,
+    MAX_REQUESTS_PER_MINUTE,
+    MAX_REQUESTS_PER_DAY_PER_IP,
+    cache_key: str = None, 
+    client_ip: str = None
+):
+    """处理API请求的主函数，根据需要处理流式或非流式请求"""
+    global current_api_key
+    
+    # 请求前基本检查
+    protect_from_abuse(
+        http_request, MAX_REQUESTS_PER_MINUTE, MAX_REQUESTS_PER_DAY_PER_IP)
+    if chat_request.model not in GeminiClient.AVAILABLE_MODELS:
+        log('error', "无效的模型", 
+            extra={'request_type': request_type, 'model': chat_request.model, 'status_code': 400})
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail="无效的模型")
+
+    # 重置已尝试的密钥
+    key_manager.reset_tried_keys_for_request()
+    # 转换消息格式
+    contents, system_instruction = GeminiClient.convert_messages(
+        GeminiClient, chat_request.messages,model=chat_request.model)
+
+    # 设置重试次数（使用可用API密钥数量作为最大重试次数）
+    retry_attempts = len(key_manager.api_keys) if key_manager.api_keys else 1
+    
+    # 尝试使用不同API密钥
+    for attempt in range(1, retry_attempts + 1):
+        # 获取密钥
+        current_api_key = key_manager.get_available_key()
+        
+        # 检查API密钥是否可用
+        if current_api_key is None:
+            log('warning', "没有可用的 API 密钥，跳过本次尝试", 
+                extra={'request_type': request_type, 'model': chat_request.model})
+            break
+        
+        # 记录当前尝试的密钥信息
+        log('info', f"第 {attempt}/{retry_attempts} 次尝试 ... 使用密钥: {current_api_key[:8]}...", 
+            extra={'key': current_api_key[:8], 'request_type': request_type, 'model': chat_request.model})
+
+        # 服务器错误重试逻辑
+        server_error_retries = 3
+        for server_retry in range(1, server_error_retries + 1):
+            try:
+                # 根据请求类型分别处理
+                if chat_request.stream:
+                    try:
+                        return await process_stream_request(
+                            chat_request,
+                            http_request,
+                            contents,
+                            system_instruction,
+                            current_api_key,
+                            key_manager,
+                            safety_settings,
+                            safety_settings_g2,
+                            api_call_stats,
+                            FAKE_STREAMING,
+                            FAKE_STREAMING_INTERVAL
+                        )
+                    except Exception as e:
+                        # 捕获流式请求的异常，但不立即返回错误，而是抛出异常让外层循环处理
+                        # 记录错误并继续尝试下一个API密钥
+                        error_detail = handle_gemini_error(e, current_api_key, key_manager)
+                        log('info', f"流式请求失败: {error_detail}",
+                            extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+                        raise
+                else:
+                    return await process_nonstream_request(
+                        chat_request,
+                        http_request,
+                        request_type,
+                        contents,
+                        system_instruction,
+                        current_api_key,
+                        response_cache_manager,
+                        active_requests_manager,
+                        safety_settings,
+                        safety_settings_g2,
+                        api_call_stats,
+                        cache_key,
+                        client_ip
+                    )
+            except HTTPException as e:
+                if e.status_code == status.HTTP_408_REQUEST_TIMEOUT:
+                    log('info', "客户端连接中断", 
+                        extra={'key': current_api_key[:8], 'request_type': request_type, 
+                              'model': chat_request.model, 'status_code': 408})
+                    raise
+                else:
+                    raise
+            except Exception as e:
+                # 使用统一的API错误处理函数
+                error_result = await handle_api_error(
+                    e, 
+                    current_api_key, 
+                    key_manager, 
+                    request_type, 
+                    chat_request.model, 
+                    server_retry - 1
+                )
+                
+                # 如果需要删除缓存，清除缓存
+                if error_result.get('remove_cache', False) and cache_key and cache_key in response_cache_manager.cache:
+                    log('info', f"因API错误，删除缓存: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'remove-on-error', 'request_type': request_type})
+                    del response_cache_manager.cache[cache_key]
+                
+                else:
+                    # 跳出循环
+                    break
+
+    # 如果所有尝试都失败
+    msg = "所有API密钥均请求失败,请稍后重试"
+    log('error', "API key 替换失败，所有API key都已尝试，请重新配置或稍后重试", extra={'request_type': 'switch_key'})
+    
+    # 对于流式请求，创建一个特殊的StreamingResponse返回错误
+    if chat_request.stream:
+        async def error_generator():
+            error_json = json.dumps({'error': {'message': msg, 'type': 'api_error'}})
+            yield f"data: {error_json}\n\n"
+            yield "data: [DONE]\n\n"
+        
+        return StreamingResponse(error_generator(), media_type="text/event-stream")
+    else:
+        # 非流式请求使用标准HTTP异常
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=msg)

app/api/routes.py

@@ -0,0 +1,217 @@
+from fastapi import APIRouter, HTTPException, Request, Depends, status
+from fastapi.responses import JSONResponse, StreamingResponse
+from app.models import ChatCompletionRequest, ChatCompletionResponse, ErrorResponse, ModelList
+from app.services import GeminiClient
+from app.utils import generate_cache_key
+
+from app.config.settings import (
+    api_call_stats,
+    BLOCKED_MODELS
+)
+import asyncio
+import time
+from app.utils.logging import log
+
+# 导入拆分后的模块
+from .auth import verify_password
+from .request_handlers import process_request
+
+# 创建路由器
+router = APIRouter()
+
+# 全局变量引用 - 这些将在main.py中初始化并传递给路由
+key_manager = None
+response_cache_manager = None
+active_requests_manager = None
+safety_settings = None
+safety_settings_g2 = None
+current_api_key = None
+FAKE_STREAMING = None
+FAKE_STREAMING_INTERVAL = None
+PASSWORD = None
+MAX_REQUESTS_PER_MINUTE = None
+MAX_REQUESTS_PER_DAY_PER_IP = None
+
+# 初始化路由器的函数
+def init_router(
+    _key_manager,
+    _response_cache_manager,
+    _active_requests_manager,
+    _safety_settings,
+    _safety_settings_g2,
+    _current_api_key,
+    _fake_streaming,
+    _fake_streaming_interval,
+    _password,
+    _max_requests_per_minute,
+    _max_requests_per_day_per_ip
+):
+    global key_manager, response_cache_manager, active_requests_manager
+    global safety_settings, safety_settings_g2, current_api_key
+    global FAKE_STREAMING, FAKE_STREAMING_INTERVAL
+    global PASSWORD, MAX_REQUESTS_PER_MINUTE, MAX_REQUESTS_PER_DAY_PER_IP
+    
+    key_manager = _key_manager
+    response_cache_manager = _response_cache_manager
+    active_requests_manager = _active_requests_manager
+    safety_settings = _safety_settings
+    safety_settings_g2 = _safety_settings_g2
+    current_api_key = _current_api_key
+    FAKE_STREAMING = _fake_streaming
+    FAKE_STREAMING_INTERVAL = _fake_streaming_interval
+    PASSWORD = _password
+    MAX_REQUESTS_PER_MINUTE = _max_requests_per_minute
+    MAX_REQUESTS_PER_DAY_PER_IP = _max_requests_per_day_per_ip
+
+# 自定义密码验证依赖
+async def custom_verify_password(request: Request):
+    await verify_password(request, PASSWORD)
+
+# API路由
+@router.get("/v1/models", response_model=ModelList)
+def list_models():
+    log('info', "Received request to list models", extra={'request_type': 'list_models', 'status_code': 200})
+    filtered_models = [model for model in GeminiClient.AVAILABLE_MODELS if model not in BLOCKED_MODELS]
+    return ModelList(data=[{"id": model, "object": "model", "created": 1678888888, "owned_by": "organization-owner"} for model in filtered_models])
+
+@router.post("/v1/chat/completions", response_model=ChatCompletionResponse)
+async def chat_completions(request: ChatCompletionRequest, http_request: Request, _: None = Depends(custom_verify_password)):
+    # 获取客户端IP
+    client_ip = http_request.client.host if http_request.client else "unknown"
+    # 流式请求直接处理，不使用缓存
+    if request.stream:
+        return await process_request(
+            request, 
+            http_request, 
+            "stream",
+            key_manager,
+            response_cache_manager,
+            active_requests_manager,
+            safety_settings,
+            safety_settings_g2,
+            api_call_stats,
+            FAKE_STREAMING,
+            FAKE_STREAMING_INTERVAL,
+            MAX_REQUESTS_PER_MINUTE,
+            MAX_REQUESTS_PER_DAY_PER_IP
+        )
+    # 生成完整缓存键 - 用于精确匹配
+    cache_key = generate_cache_key(request)
+    
+    # 记录请求缓存键信息
+    log('info', f"请求缓存键: {cache_key[:8]}...", 
+        extra={'cache_key': cache_key[:8], 'request_type': 'non-stream'})
+    
+    # 检查精确缓存是否存在且未过期
+    cached_response, cache_hit = response_cache_manager.get(cache_key)
+    if cache_hit:
+        # 精确缓存命中
+        log('info', f"精确缓存命中: {cache_key[:8]}...", 
+            extra={'cache_operation': 'hit', 'request_type': 'non-stream'})
+        
+        # 同时清理相关的活跃任务，避免后续请求等待已经不需要的任务
+        active_requests_manager.remove_by_prefix(f"cache:{cache_key}")
+        
+        # 安全删除缓存
+        if cache_key in response_cache_manager.cache:
+            del response_cache_manager.cache[cache_key]
+            log('info', f"缓存使用后已删除: {cache_key[:8]}...", 
+                extra={'cache_operation': 'used-and-removed', 'request_type': 'non-stream'})
+        
+        # 返回缓存响应
+        return cached_response
+    
+    # 构建包含缓存键的活跃请求池键
+    pool_key = f"cache:{cache_key}"
+    
+    # 查找所有使用相同缓存键的活跃任务
+    active_task = active_requests_manager.get(pool_key)
+    if active_task and not active_task.done():
+        log('info', f"发现相同请求的进行中任务", 
+            extra={'request_type': 'non-stream', 'model': request.model})
+        
+        # 等待已有任务完成
+        try:
+            # 设置超时，避免无限等待
+            await asyncio.wait_for(active_task, timeout=180)
+            
+            # 通过缓存管理器获取已完成任务的结果
+            cached_response, cache_hit = response_cache_manager.get(cache_key)
+            if cache_hit:
+                # 安全删除缓存
+                if cache_key in response_cache_manager.cache:
+                    del response_cache_manager.cache[cache_key]
+                    log('info', f"使用已完成任务的缓存后删除: {cache_key[:8]}...", 
+                        extra={'cache_operation': 'used-and-removed', 'request_type': 'non-stream'})
+                
+                return cached_response
+                
+            # 如果缓存已被清除或不存在，使用任务结果
+            if active_task.done() and not active_task.cancelled():
+                result = active_task.result()
+                if result:
+                    # 使用原始结果时，我们需要创建一个新的响应对象
+                    # 避免使用可能已被其他请求修改的对象
+                    new_response = ChatCompletionResponse(
+                        id=f"chatcmpl-{int(time.time()*1000)}",
+                        object="chat.completion", 
+                        created=int(time.time()),
+                        model=result.model,
+                        choices=result.choices
+                    )
+                    
+                    # 不要缓存此结果，因为它很可能是一个已存在但被使用后清除的缓存
+                    return new_response
+        except (asyncio.TimeoutError, asyncio.CancelledError) as e:
+            # 任务超时或被取消的情况下，记录日志然后让代码继续执行
+            error_type = "超时" if isinstance(e, asyncio.TimeoutError) else "被取消"
+            log('warning', f"等待已有任务{error_type}: {pool_key}", 
+                extra={'request_type': 'non-stream', 'model': request.model})
+            
+            # 从活跃请求池移除该任务
+            if active_task.done() or active_task.cancelled():
+                active_requests_manager.remove(pool_key)
+                log('info', f"已从活跃请求池移除{error_type}任务: {pool_key}", 
+                    extra={'request_type': 'non-stream'})
+     
+    # 创建非流式请求处理任务
+    process_task = asyncio.create_task(
+        process_request(
+            request, 
+            http_request, 
+            "non-stream",
+            key_manager,
+            response_cache_manager,
+            active_requests_manager,
+            safety_settings,
+            safety_settings_g2,
+            api_call_stats,
+            FAKE_STREAMING,
+            FAKE_STREAMING_INTERVAL,
+            MAX_REQUESTS_PER_MINUTE,
+            MAX_REQUESTS_PER_DAY_PER_IP,
+            cache_key,
+            client_ip
+        )
+    )
+    
+    # 将任务添加到活跃请求池
+    active_requests_manager.add(pool_key, process_task)
+    
+    # 等待任务完成
+    try:
+        response = await process_task
+        return response
+    except Exception as e:
+        # 如果任务失败，从活跃请求池中移除
+        active_requests_manager.remove(pool_key)
+        
+        # 检查是否已有缓存的结果（可能是由另一个任务创建的）
+        cached_response, cache_hit = response_cache_manager.get(cache_key)
+        if cache_hit:
+            log('info', f"任务失败但找到缓存，使用缓存结果: {cache_key[:8]}...", 
+                extra={'request_type': 'non-stream', 'model': request.model})
+            return cached_response
+        
+        # 重新抛出异常
+        raise

app/api/stream_handlers.py

@@ -0,0 +1,284 @@
+import asyncio
+import json
+import time
+import random
+from fastapi import Request
+from fastapi.responses import StreamingResponse
+from app.models import ChatCompletionRequest
+from app.services import GeminiClient
+from app.utils import handle_gemini_error, update_api_call_stats
+from app.utils.logging import log
+
+# 流式请求处理函数
+async def process_stream_request(
+    chat_request: ChatCompletionRequest,
+    http_request: Request,
+    contents,
+    system_instruction,
+    current_api_key: str,
+    key_manager,
+    safety_settings,
+    safety_settings_g2,
+    api_call_stats,
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL
+) -> StreamingResponse:
+    """处理流式API请求"""
+    
+    # 创建一个直接流式响应的生成器函数
+    async def stream_response_generator():
+        # 如果启用了假流式模式，使用随机遍历API密钥的方式
+        if FAKE_STREAMING:
+            # 创建一个队列用于在任务之间传递数据
+            queue = asyncio.Queue()
+            keep_alive_task = None
+            api_request_task = None
+            
+            try:
+                # 创建一个保持连接的任务，持续发送换行符
+                async def keep_alive_sender():
+                    try:
+                        # 创建一个Gemini客户端用于发送保持连接的换行符
+                        keep_alive_client = GeminiClient(current_api_key)
+                        
+                        # 启动保持连接的生成器
+                        keep_alive_generator = keep_alive_client.stream_chat(
+                            chat_request,
+                            contents,
+                            safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
+                            system_instruction
+                        )
+                        
+                        # 持续发送换行符直到被取消
+                        async for line in keep_alive_generator:
+                            if line == "\n":
+                                # 将换行符格式化为SSE格式
+                                formatted_chunk = {
+                                    "id": "chatcmpl-keepalive",
+                                    "object": "chat.completion.chunk",
+                                    "created": int(time.time()),
+                                    "model": chat_request.model,
+                                    "choices": [{"delta": {"content": ""}, "index": 0, "finish_reason": None}]
+                                }
+                                # 将格式化的换行符放入队列
+                                await queue.put(f"data: {json.dumps(formatted_chunk)}\n\n")
+                    except asyncio.CancelledError:
+                        # log('info', "保持连接任务被取消",
+                        #     extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        raise
+                    except Exception as e:
+                        log('error', f"保持连接任务出错: {str(e)}",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        # 将错误放入队列
+                        await queue.put(None)
+                        raise
+                
+                # 创建一个任务来随机遍历API密钥并请求内容
+                async def api_request_handler():
+                    success = False
+                    try:
+                        # 重置已尝试的密钥
+                        key_manager.reset_tried_keys_for_request()
+                        
+                        # 获取可用的API密钥
+                        available_keys = key_manager.api_keys.copy()
+                        random.shuffle(available_keys)  # 随机打乱密钥顺序
+                        
+                        # 遍历所有API密钥尝试获取响应
+                        for attempt, api_key in enumerate(available_keys, 1):
+                            try:
+                                log('info', f"假流式模式: 尝试API密钥 {api_key[:8]}... ({attempt}/{len(available_keys)})",
+                                    extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                                
+                                # 创建一个新的客户端使用当前API密钥
+                                non_stream_client = GeminiClient(api_key)
+                                
+                                # 使用非流式方式请求内容
+                                response_content = await asyncio.to_thread(
+                                    non_stream_client.complete_chat,
+                                    chat_request,
+                                    contents,
+                                    safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
+                                    system_instruction
+                                )
+                                
+                                # 检查响应是否有效
+                                if response_content and response_content.text:
+                                    log('info', f"假流式模式: API密钥 {api_key[:8]}... 成功获取响应",
+                                        extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                                    
+                                    # 将完整响应分割成小块，模拟流式返回
+                                    full_text = response_content.text
+                                    chunk_size = max(len(full_text) // 10, 1)  # 至少分成10块，每块至少1个字符
+                                    
+                                    for i in range(0, len(full_text), chunk_size):
+                                        chunk = full_text[i:i+chunk_size]
+                                        formatted_chunk = {
+                                            "id": "chatcmpl-someid",
+                                            "object": "chat.completion.chunk",
+                                            "created": int(time.time()),
+                                            "model": chat_request.model,
+                                            "choices": [{"delta": {"role": "assistant", "content": chunk}, "index": 0, "finish_reason": None}]
+                                        }
+                                        # 将格式化的内容块放入队列
+                                        await queue.put(f"data: {json.dumps(formatted_chunk)}\n\n")
+                                    
+                                    success = True
+                                    # 更新API调用统计
+                                    update_api_call_stats(api_call_stats, endpoint=api_key,model=chat_request.model)
+                                    break  # 成功获取响应，退出循环
+                                else:
+                                    log('warning', f"假流式模式: API密钥 {api_key[:8]}... 返回空响应",
+                                        extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                            except Exception as e:
+                                error_detail = handle_gemini_error(e, api_key, key_manager)
+                                log('error', f"假流式模式: API密钥 {api_key[:8]}... 请求失败: {error_detail}",
+                                    extra={'key': api_key[:8], 'request_type': 'fake-stream', 'model': chat_request.model})
+                                # 继续尝试下一个API密钥
+                        
+                        # 如果所有API密钥都尝试失败
+                        if not success:
+                            error_msg = "所有API密钥均请求失败，请稍后重试"
+                            log('error', error_msg,
+                                extra={'key': 'ALL', 'request_type': 'fake-stream', 'model': chat_request.model})
+                            
+                            # 添加错误信息到队列
+                            error_json = {
+                                "id": "chatcmpl-error",
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": chat_request.model,
+                                "choices": [{"delta": {"content": f"\n\n[错误: {error_msg}]"}, "index": 0, "finish_reason": "error"}]
+                            }
+                            await queue.put(f"data: {json.dumps(error_json)}\n\n")
+                        
+                        # 添加完成标记到队列
+                        await queue.put("data: [DONE]\n\n")
+                        # 添加None表示队列结束
+                        await queue.put(None)
+                        
+                    except asyncio.CancelledError:
+                        log('info', "API请求任务被取消",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        # 添加None表示队列结束
+                        await queue.put(None)
+                        raise
+                    except Exception as e:
+                        log('error', f"API请求任务出错: {str(e)}",
+                            extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                        # 添加错误信息到队列
+                        error_json = {
+                            "id": "chatcmpl-error",
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": chat_request.model,
+                            "choices": [{"delta": {"content": f"\n\n[错误: {str(e)}]"}, "index": 0, "finish_reason": "error"}]
+                        }
+                        await queue.put(f"data: {json.dumps(error_json)}\n\n")
+                        await queue.put("data: [DONE]\n\n")
+                        # 添加None表示队列结束
+                        await queue.put(None)
+                        raise
+                
+                # 启动保持连接的任务
+                keep_alive_task = asyncio.create_task(keep_alive_sender())
+                # 启动API请求任务
+                api_request_task = asyncio.create_task(api_request_handler())
+                
+                # 从队列中获取数据并发送给客户端
+                while True:
+                    chunk = await queue.get()
+                    if chunk is None:  # None表示队列结束
+                        break
+                    yield chunk
+                    
+                    # 如果API请求任务已完成，取消保持连接任务
+                    if api_request_task.done() and not keep_alive_task.done():
+                        keep_alive_task.cancel()
+                
+            except asyncio.CancelledError:
+                log('info', "流式响应生成器被取消",
+                    extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                # 取消所有任务
+                if keep_alive_task and not keep_alive_task.done():
+                    keep_alive_task.cancel()
+                if api_request_task and not api_request_task.done():
+                    api_request_task.cancel()
+            except Exception as e:
+                log('error', f"流式响应生成器出错: {str(e)}",
+                    extra={'key': current_api_key[:8], 'request_type': 'fake-stream'})
+                # 取消所有任务
+                if keep_alive_task and not keep_alive_task.done():
+                    keep_alive_task.cancel()
+                if api_request_task and not api_request_task.done():
+                    api_request_task.cancel()
+                # 发送错误信息给客户端
+                error_json = {
+                    "id": "chatcmpl-error",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": chat_request.model,
+                    "choices": [{"delta": {"content": f"\n\n[错误: {str(e)}]"}, "index": 0, "finish_reason": "error"}]
+                }
+                yield f"data: {json.dumps(error_json)}\n\n"
+                yield "data: [DONE]\n\n"
+            finally:
+                # 确保所有任务都被取消
+                if keep_alive_task and not keep_alive_task.done():
+                    keep_alive_task.cancel()
+                if api_request_task and not api_request_task.done():
+                    api_request_task.cancel()
+        else:
+            # 原始流式请求处理逻辑
+            gemini_client = GeminiClient(current_api_key)
+            success = False
+            
+            try:
+                # 直接迭代生成器并发送响应块
+                async for chunk in gemini_client.stream_chat(
+                    chat_request,
+                    contents,
+                    safety_settings_g2 if 'gemini-2.0-flash-exp' in chat_request.model else safety_settings,
+                    system_instruction
+                ):
+                    # 空字符串跳过
+                    if not chunk:
+                        continue
+                        
+                    formatted_chunk = {
+                        "id": "chatcmpl-someid",
+                        "object": "chat.completion.chunk",
+                        "created": int(time.time()),
+                        "model": chat_request.model,
+                        "choices": [{"delta": {"role": "assistant", "content": chunk}, "index": 0, "finish_reason": None}]
+                    }
+                    success = True  # 只要有一个chunk成功，就标记为成功
+                    yield f"data: {json.dumps(formatted_chunk)}\n\n"
+                
+                # 如果成功获取到响应，更新API调用统计
+                if success:
+                    update_api_call_stats(api_call_stats,endpoint=current_api_key,model=chat_request.model)
+                    
+                yield "data: [DONE]\n\n"
+                
+            except asyncio.CancelledError:
+                log('info', "客户端连接已中断", 
+                    extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+            except Exception as e:
+                error_detail = handle_gemini_error(e, current_api_key, key_manager)
+                log('error', f"流式请求失败: {error_detail}",
+                    extra={'key': current_api_key[:8], 'request_type': 'stream', 'model': chat_request.model})
+                # 发送错误信息给客户端
+                error_json = {
+                    "id": "chatcmpl-error",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": chat_request.model,
+                    "choices": [{"delta": {"content": f"\n\n[错误: {error_detail}]"}, "index": 0, "finish_reason": "error"}]
+                }
+                yield f"data: {json.dumps(error_json)}\n\n"
+                yield "data: [DONE]\n\n"
+                # 重新抛出异常，这样process_request可以捕获它
+                raise e
+    
+    return StreamingResponse(stream_response_generator(), media_type="text/event-stream")

app/config/__init__.py

@@ -0,0 +1,3 @@
+# 配置模块初始化文件
+from app.config.settings import *
+from app.config.safety import *

app/config/safety.py

@@ -0,0 +1,49 @@
+# 安全设置配置
+
+# Gemini 1.0 安全设置
+SAFETY_SETTINGS = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'BLOCK_NONE'
+    }
+]
+
+# Gemini 2.0 安全设置
+SAFETY_SETTINGS_G2 = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'OFF'
+    }
+]

app/config/settings.py

@@ -0,0 +1,81 @@
+import os
+import pathlib
+import logging
+from datetime import datetime, timedelta
+
+# 基础目录设置
+BASE_DIR = pathlib.Path(__file__).parent.parent
+
+# 流式响应配置
+FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1", "yes"]
+# 假流式请求的空内容返回间隔（秒）
+FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
+
+#随机字符串
+RANDOM_STRING = os.environ.get("RANDOM_STRING", "true").lower() in ["true", "1", "yes"]
+RANDOM_STRING_LENGTH = int(os.environ.get("RANDOM_STRING_LENGTH", "5"))
+
+
+# 日志配置
+logging.getLogger("uvicorn").disabled = True
+logging.getLogger("uvicorn.access").disabled = True
+
+# 安全配置
+PASSWORD = os.environ.get("PASSWORD", "123").strip('"')
+MAX_REQUESTS_PER_MINUTE = int(os.environ.get("MAX_REQUESTS_PER_MINUTE", "30"))
+MAX_REQUESTS_PER_DAY_PER_IP = int(os.environ.get("MAX_REQUESTS_PER_DAY_PER_IP", "600"))
+RETRY_DELAY = 1
+MAX_RETRY_DELAY = 16
+
+# API密钥使用限制
+# 默认每个API密钥每24小时可使用次数
+API_KEY_DAILY_LIMIT = int(os.environ.get("API_KEY_DAILY_LIMIT", "100"))
+
+# 缓存配置
+CACHE_EXPIRY_TIME = int(os.environ.get("CACHE_EXPIRY_TIME", "1200"))  # 默认20分钟
+MAX_CACHE_ENTRIES = int(os.environ.get("MAX_CACHE_ENTRIES", "500"))  # 默认最多缓存500条响应
+REMOVE_CACHE_AFTER_USE = os.environ.get("REMOVE_CACHE_AFTER_USE", "true").lower() in ["true", "1", "yes"]
+
+# 请求历史配置
+REQUEST_HISTORY_EXPIRY_TIME = int(os.environ.get("REQUEST_HISTORY_EXPIRY_TIME", "600"))  # 默认10分钟
+ENABLE_RECONNECT_DETECTION = os.environ.get("ENABLE_RECONNECT_DETECTION", "true").lower() in ["true", "1", "yes"]
+
+serach={
+    "search_mode":os.environ.get("SERACH_MODE", "true").lower() in ["true", "1", "yes"],
+    "search_prompt":os.environ.get("SERACH_PROMPT", "（使用搜索工具联网搜索，需要在content中结合搜索内容）").strip('"')
+}
+
+version={
+    "local_version":"0.0.0",
+    "remote_version":"0.0.0",
+    "has_update":False
+}
+
+# API调用统计
+api_call_stats = {
+    'last_24h': {
+        'total': {},  # 按小时统计过去24小时总调用次数
+        'by_endpoint': {}  # 按API端点分类的24小时统计（也用于API密钥统计）
+    },
+    'hourly': {
+        'total': {},  # 按小时统计过去一小时总调用次数
+        'by_endpoint': {}  # 按API端点分类的小时统计（也用于API密钥统计）
+    },
+    'minute': {
+        'total': {},  # 按分钟统计过去一分钟总调用次数
+        'by_endpoint': {}  # 按API端点分类的分钟统计（也用于API密钥统计）
+    }
+}
+
+# 客户端IP到最近请求的映射，用于识别重连请求
+client_request_history = {}
+
+# 模型屏蔽列表配置
+# 默认屏蔽的模型列表
+DEFAULT_BLOCKED_MODELS = []
+
+# 从环境变量中读取屏蔽模型列表，如果未设置则使用默认列表
+# 环境变量格式应为逗号分隔的模型名称字符串
+BLOCKED_MODELS = os.environ.get("BLOCKED_MODELS", ",".join(DEFAULT_BLOCKED_MODELS))
+# 将字符串转换为列表
+BLOCKED_MODELS = [model.strip() for model in BLOCKED_MODELS.split(",") if model.strip()]

app/main.py

@@ -0,0 +1,283 @@
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from app.models import ErrorResponse
+from app.services import GeminiClient
+from app.utils import (
+    APIKeyManager, 
+    test_api_key, 
+    format_log_message, 
+    log_manager,
+    ResponseCacheManager,
+    ActiveRequestsManager,
+    clean_expired_stats,
+    update_api_call_stats,
+    check_version,
+    schedule_cache_cleanup,
+    handle_exception,
+    log
+)
+from app.api import router, init_router, dashboard_router, init_dashboard_router
+from app.config.settings import (
+    FAKE_STREAMING,
+    FAKE_STREAMING_INTERVAL,
+    RANDOM_STRING,
+    RANDOM_STRING_LENGTH,
+    PASSWORD,
+    MAX_REQUESTS_PER_MINUTE,
+    MAX_REQUESTS_PER_DAY_PER_IP,
+    RETRY_DELAY,
+    MAX_RETRY_DELAY,
+    CACHE_EXPIRY_TIME,
+    MAX_CACHE_ENTRIES,
+    REMOVE_CACHE_AFTER_USE,
+    REQUEST_HISTORY_EXPIRY_TIME,
+    ENABLE_RECONNECT_DETECTION,
+    api_call_stats,
+    client_request_history,
+    version,
+    API_KEY_DAILY_LIMIT
+)
+from app.config.safety import SAFETY_SETTINGS, SAFETY_SETTINGS_G2
+import os
+import json
+import asyncio
+import time
+import logging
+from datetime import datetime, timedelta
+import sys
+import pathlib
+import threading
+from concurrent.futures import ThreadPoolExecutor
+
+# 设置模板目录
+BASE_DIR = pathlib.Path(__file__).parent
+templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
+
+app = FastAPI(limit="50M")
+
+# --------------- 全局实例 ---------------
+
+# 初始化API密钥管理器
+key_manager = APIKeyManager()
+current_api_key = key_manager.get_available_key()
+
+# 创建全局缓存字典，将作为缓存管理器的内部存储
+response_cache = {}
+
+# 初始化缓存管理器，使用全局字典作为存储
+response_cache_manager = ResponseCacheManager(
+    expiry_time=CACHE_EXPIRY_TIME,
+    max_entries=MAX_CACHE_ENTRIES,
+    remove_after_use=REMOVE_CACHE_AFTER_USE,
+    cache_dict=response_cache
+)
+
+# 活跃请求池 - 将作为活跃请求管理器的内部存储
+active_requests_pool = {}
+
+# 初始化活跃请求管理器
+active_requests_manager = ActiveRequestsManager(requests_pool=active_requests_pool)
+
+# --------------- 工具函数 ---------------
+
+def switch_api_key():
+    global current_api_key
+    key = key_manager.get_available_key() # get_available_key 会处理栈的逻辑
+    if key:
+        current_api_key = key
+        log('info', f"API key 替换为 → {current_api_key[:8]}...", extra={'key': current_api_key[:8], 'request_type': 'switch_key'})
+    else:
+        log('error', "API key 替换失败，所有API key都已尝试，请重新配置或稍后重试", extra={'key': 'N/A', 'request_type': 'switch_key', 'status_code': 'N/A'})
+
+async def check_key(key):
+    """检查单个API密钥是否有效"""
+    is_valid = await test_api_key(key)
+    status_msg = "有效" if is_valid else "无效"
+    log('info', f"API Key {key[:10]}... {status_msg}.")
+    return key if is_valid else None
+
+def check_key_in_thread(key):
+    """在线程中运行异步检查密钥函数"""
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    try:
+        valid_key = loop.run_until_complete(check_key(key))
+        if valid_key:
+            # 如果密钥有效，立即添加到可用列表中
+            key_manager.api_keys.append(valid_key)
+            # 重置密钥栈以包含新的有效密钥
+            key_manager._reset_key_stack()
+            log('info', f"API Key {valid_key[:8]}... 已添加到可用列表")
+        return valid_key
+    finally:
+        loop.close()
+
+async def check_keys():
+    """启动线程池来并行检查所有密钥"""
+    # 保存原始密钥列表的副本
+    all_keys = key_manager.api_keys.copy()
+    # 清空当前密钥列表，将在检查过程中逐个添加有效密钥
+    key_manager.api_keys = []
+    
+    log('info', f"开始在单独线程中检查 {len(all_keys)} 个API密钥...")
+    
+    # 创建线程池
+    with ThreadPoolExecutor(max_workers=min(10, len(all_keys))) as executor:
+        # 提交所有密钥检查任务
+        future_to_key = {executor.submit(check_key_in_thread, key): key for key in all_keys}
+        
+        # 等待所有任务完成
+        for future in future_to_key:
+            try:
+                future.result()  # 获取结果但不需要处理，因为check_key_in_thread已经处理了有效密钥
+            except Exception as exc:
+                log('error', f"检查密钥时发生错误: {exc}")
+    
+    if not key_manager.api_keys:
+        log('error', "没有可用的 API 密钥！", extra={'key': 'N/A', 'request_type': 'startup', 'status_code': 'N/A'})
+    
+    return key_manager.api_keys
+
+# 设置全局异常处理
+sys.excepthook = handle_exception
+
+# --------------- 事件处理 ---------------
+
+@app.on_event("startup")
+async def startup_event():
+    log('info', "Starting Gemini API proxy...")
+    
+    # 启动缓存清理定时任务
+    schedule_cache_cleanup(response_cache_manager, active_requests_manager)
+    
+    # 检查版本
+    await check_version()
+    
+    # 先同步检查一个密钥，用于加载可用模型
+    all_keys = key_manager.api_keys.copy()
+    key_manager.api_keys = []  # 清空当前密钥列表
+    
+    # 尝试找到一个有效的密钥
+    valid_key_found = False
+    for key in all_keys:
+        is_valid = await test_api_key(key)
+        if is_valid:
+            key_manager.api_keys.append(key)
+            key_manager._reset_key_stack()
+            log('info', f"初始检查: API Key {key[:8]}... 有效，已添加到可用列表")
+            valid_key_found = True
+            
+            # 使用这个有效密钥加载可用模型
+            try:
+                all_models = await GeminiClient.list_available_models(key)
+                GeminiClient.AVAILABLE_MODELS = [model.replace(
+                    "models/", "") for model in all_models]
+                log('info', "Available models loaded.")
+            except Exception as e:
+                log('warning', f"无法加载可用模型: {str(e)}")
+            
+            break  # 找到一个有效密钥后就跳出循环
+    
+    if not valid_key_found:
+        log('warning', "初始检查未找到有效密钥，将在后台继续检查")
+    
+    # 在后台线程中检查剩余的密钥
+    remaining_keys = [k for k in all_keys if k not in key_manager.api_keys]
+    if remaining_keys:
+        def check_remaining_keys():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                # 创建线程池检查剩余密钥
+                with ThreadPoolExecutor(max_workers=min(10, len(remaining_keys))) as executor:
+                    future_to_key = {executor.submit(check_key_in_thread, key): key for key in remaining_keys}
+                    for future in future_to_key:
+                        try:
+                            future.result()
+                        except Exception as exc:
+                            log('error', f"检查密钥时发生错误: {exc}")
+            finally:
+                loop.close()
+                log('info', f"后台密钥检查完成，当前可用密钥数量: {len(key_manager.api_keys)}")
+        
+        # 启动后台线程检查剩余密钥
+        threading.Thread(target=check_remaining_keys, daemon=True).start()
+        log('info', f"后台线程已启动，正在检查剩余的 {len(remaining_keys)} 个API密钥...")
+    
+    # 显示当前可用密钥
+    key_manager.show_all_keys()
+    log('info', f"当前可用 API 密钥数量：{len(key_manager.api_keys)}")
+    log('info', f"最大重试次数设置为：{len(key_manager.api_keys)}")
+    
+    # 初始化路由器
+    init_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager,
+        SAFETY_SETTINGS,
+        SAFETY_SETTINGS_G2,
+        current_api_key,
+        FAKE_STREAMING,
+        FAKE_STREAMING_INTERVAL,
+        PASSWORD,
+        MAX_REQUESTS_PER_MINUTE,
+        MAX_REQUESTS_PER_DAY_PER_IP
+    )
+    
+    # 初始化仪表盘路由器
+    init_dashboard_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager
+    )
+    
+    # 初始化路由器
+    init_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager,
+        SAFETY_SETTINGS,
+        SAFETY_SETTINGS_G2,
+        current_api_key,
+        FAKE_STREAMING,
+        FAKE_STREAMING_INTERVAL,
+        PASSWORD,
+        MAX_REQUESTS_PER_MINUTE,
+        MAX_REQUESTS_PER_DAY_PER_IP
+    )
+    
+    # 初始化仪表盘路由器
+    init_dashboard_router(
+        key_manager,
+        response_cache_manager,
+        active_requests_manager
+    )
+
+# --------------- 异常处理 ---------------
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    from app.utils import translate_error
+    error_message = translate_error(str(exc))
+    extra_log_unhandled_exception = {'status_code': 500, 'error_message': error_message}
+    log('error', f"Unhandled exception: {error_message}", extra=extra_log_unhandled_exception)
+    return JSONResponse(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=ErrorResponse(message=str(exc), type="internal_error").dict())
+
+# --------------- 路由 ---------------
+
+# 包含API路由
+app.include_router(router)
+app.include_router(dashboard_router)
+
+# 挂载静态文件目录
+app.mount("/assets", StaticFiles(directory="app/templates/assets"), name="assets")
+
+@app.get("/", response_class=HTMLResponse)
+async def root(request: Request):
+    """
+    根路由 - 返回静态 HTML 文件
+    """
+    # 直接返回 index.html 文件
+    return templates.TemplateResponse("index.html", {"request": request})

app/models/__init__.py

@@ -0,0 +1,19 @@
+from app.models.schemas import (
+    Message,
+    ChatCompletionRequest,
+    Choice,
+    Usage,
+    ChatCompletionResponse,
+    ErrorResponse,
+    ModelList
+)
+
+__all__ = [
+    'Message',
+    'ChatCompletionRequest',
+    'Choice',
+    'Usage',
+    'ChatCompletionResponse',
+    'ErrorResponse',
+    'ModelList'
+]

app/models/schemas.py

@@ -0,0 +1,46 @@
+from typing import List, Dict, Optional, Union, Literal, Any
+from pydantic import BaseModel, Field
+
+class Message(BaseModel):
+    role: str
+    content: Union[str, List[Dict[str, Any]]]
+
+class ChatCompletionRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    temperature: float = 0.7
+    top_p: Optional[float] = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: Optional[Union[str, List[str]]] = None
+    max_tokens: Optional[int] = None
+    presence_penalty: Optional[float] = 0.0
+    frequency_penalty: Optional[float] = 0.0
+
+class Choice(BaseModel):
+    index: int
+    message: Message
+    finish_reason: Optional[str] = None
+
+class Usage(BaseModel):
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+class ChatCompletionResponse(BaseModel):
+    id: str
+    object: Literal["chat.completion"]
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Usage = Field(default_factory=Usage)
+
+class ErrorResponse(BaseModel):
+    message: str
+    type: str
+    param: Optional[str] = None
+    code: Optional[str] = None
+
+class ModelList(BaseModel):
+    object: str = "list"
+    data: List[Dict]

app/services/__init__.py

@@ -0,0 +1,7 @@
+from app.services.gemini import GeminiClient, ResponseWrapper, GeneratedText
+
+__all__ = [
+    'GeminiClient',
+    'ResponseWrapper',
+    'GeneratedText'
+]

app/services/gemini.py

@@ -0,0 +1,367 @@
+import requests
+import json
+import os
+import asyncio
+import time
+from app.models import ChatCompletionRequest, Message
+from dataclasses import dataclass
+from typing import Optional, Dict, Any, List
+import httpx
+import logging
+import secrets
+import string
+from app.utils import format_log_message
+from app.config import settings
+from app.config.settings import (    
+    RANDOM_STRING,
+    RANDOM_STRING_LENGTH,
+    serach
+)
+from app.utils.logging import log
+
+def generate_secure_random_string(length):
+    all_characters = string.ascii_letters + string.digits
+    secure_random_string = ''.join(secrets.choice(all_characters) for _ in range(length))
+    return secure_random_string
+
+logger = logging.getLogger('my_logger')
+
+# 是否启用假流式请求 默认启用
+FAKE_STREAMING = os.environ.get("FAKE_STREAMING", "true").lower() in ["true", "1", "yes"]
+# 假流式请求的空内容返回间隔（秒）
+FAKE_STREAMING_INTERVAL = float(os.environ.get("FAKE_STREAMING_INTERVAL", "1"))
+
+@dataclass
+class GeneratedText:
+    text: str
+    finish_reason: Optional[str] = None
+
+
+class ResponseWrapper:
+    def __init__(self, data: Dict[Any, Any]):  # 正确的初始化方法名
+        self._data = data
+        self._text = self._extract_text()
+        self._finish_reason = self._extract_finish_reason()
+        self._prompt_token_count = self._extract_prompt_token_count()
+        self._candidates_token_count = self._extract_candidates_token_count()
+        self._total_token_count = self._extract_total_token_count()
+        self._thoughts = self._extract_thoughts()
+        self._json_dumps = json.dumps(self._data, indent=4, ensure_ascii=False)
+
+    def _extract_thoughts(self) -> Optional[str]:
+        try:
+            for part in self._data['candidates'][0]['content']['parts']:
+                if 'thought' in part:
+                    return part['text']
+            return ""
+        except (KeyError, IndexError):
+            return ""
+
+    def _extract_text(self) -> str:
+        try:
+            text=""
+            for part in self._data['candidates'][0]['content']['parts']:
+                if 'thought' not in part:
+                    text+=part['text']
+            return part['text']
+        except (KeyError, IndexError):
+            return ""
+
+    def _extract_finish_reason(self) -> Optional[str]:
+        try:
+            return self._data['candidates'][0].get('finishReason')
+        except (KeyError, IndexError):
+            return None
+
+    def _extract_prompt_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('promptTokenCount')
+        except (KeyError):
+            return None
+
+    def _extract_candidates_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('candidatesTokenCount')
+        except (KeyError):
+            return None
+
+    def _extract_total_token_count(self) -> Optional[int]:
+        try:
+            return self._data['usageMetadata'].get('totalTokenCount')
+        except (KeyError):
+            return None
+
+    @property
+    def text(self) -> str:
+        return self._text
+
+    @property
+    def finish_reason(self) -> Optional[str]:
+        return self._finish_reason
+
+    @property
+    def prompt_token_count(self) -> Optional[int]:
+        return self._prompt_token_count
+
+    @property
+    def candidates_token_count(self) -> Optional[int]:
+        return self._candidates_token_count
+
+    @property
+    def total_token_count(self) -> Optional[int]:
+        return self._total_token_count
+
+    @property
+    def thoughts(self) -> Optional[str]:
+        return self._thoughts
+
+    @property
+    def json_dumps(self) -> str:
+        return self._json_dumps
+
+
+class GeminiClient:
+
+    AVAILABLE_MODELS = []
+    EXTRA_MODELS = os.environ.get("EXTRA_MODELS", "").split(",")
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    # 将流式和非流式请求的通用部分提取为共享方法
+    def _prepare_request_data(self, request, contents, safety_settings, system_instruction):
+        api_version = "v1alpha" if "think" in request.model else "v1beta"
+        if serach["search_mode"]:
+            data = {
+                "contents": contents,
+                "tools": [{"google_search": {}}],
+                "generationConfig": self._get_generation_config(request),
+                "safetySettings": safety_settings,
+            }
+        else:
+            data = {
+                "contents": contents,
+                "generationConfig": self._get_generation_config(request),
+                "safetySettings": safety_settings,
+            }
+        if system_instruction:
+            data["system_instruction"] = system_instruction
+        return api_version, data
+    
+    def _get_generation_config(self, request):
+        config_params = {
+            "temperature": request.temperature,
+            "maxOutputTokens": request.max_tokens,
+            "topP": request.top_p,
+            "stopSequences": request.stop if isinstance(request.stop, list) else [request.stop] if request.stop is not None else None,
+            "candidateCount": request.n
+        }
+        return {k: v for k, v in config_params.items() if v is not None}
+
+    async def stream_chat(self, request: ChatCompletionRequest, contents, safety_settings, system_instruction):
+        
+        # 检查是否启用假流式请求
+        if FAKE_STREAMING:
+            extra_log={'key': self.api_key[:8], 'request_type': 'fake_stream', 'model': request.model}
+            log('INFO', "使用假流式请求模式（发送换行符保持连接）", extra=extra_log)
+            try:
+                
+                # 每隔一段时间发送换行符作为保活消息，直到外部取消此生成器
+                start_time = time.time()
+                while True:
+                    yield "\n"
+                    await asyncio.sleep(FAKE_STREAMING_INTERVAL)
+                    
+                    # 如果等待时间过长（超过300秒），抛出超时异常，让外部处理
+                    if time.time() - start_time > 300:
+                        log('ERROR', f"假流式请求等待时间过长",extra=extra_log)
+                        
+                        raise TimeoutError("假流式请求等待时间过长")
+                
+            except Exception as e:
+                if not isinstance(e, asyncio.CancelledError):  
+                    log('ERROR', f"假流式处理期间发生错误: {str(e)}", extra=extra_log)
+                raise e
+            finally:
+                log('INFO', "假流式请求结束", extra=extra_log)
+        else:
+            # 真流式请求处理逻辑
+            extra_log = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model}
+            log('INFO', "真流式请求开始", extra=extra_log)
+            
+            api_version, data = self._prepare_request_data(request, contents, safety_settings, system_instruction)
+            model= request.model.removesuffix("-search")
+            url = f"https://generativelanguage.googleapis.com/{api_version}/models/{model}:streamGenerateContent?key={self.api_key}&alt=sse"
+            headers = {
+                "Content-Type": "application/json",
+            }
+            
+            async with httpx.AsyncClient() as client:
+                async with client.stream("POST", url, headers=headers, json=data, timeout=600) as response:
+                    buffer = b""
+                    try:
+                        async for line in response.aiter_lines():
+                            if not line.strip():
+                                continue
+                            if line.startswith("data: "):
+                                line = line[len("data: "):]
+                            buffer += line.encode('utf-8')
+                            try:
+                                data = json.loads(buffer.decode('utf-8'))
+                                buffer = b""
+                                if 'candidates' in data and data['candidates']:
+                                    candidate = data['candidates'][0]
+                                    if 'content' in candidate:
+                                        content = candidate['content']
+                                        if 'parts' in content and content['parts']:
+                                            parts = content['parts']
+                                            text = ""
+                                            for part in parts:
+                                                if 'text' in part:
+                                                    text += part['text']
+                                            if text:
+                                                yield text
+                                            
+                                    if candidate.get("finishReason") and candidate.get("finishReason") != "STOP":
+                                        error_msg = f"模型的响应被截断: {candidate.get('finishReason')}"
+                                        extra_log_error = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                                        log_msg = format_log_message('WARNING', error_msg, extra=extra_log_error)
+                                        logger.warning(log_msg)
+                                        raise ValueError(error_msg)
+                                    
+                                    if 'safetyRatings' in candidate:
+                                        for rating in candidate['safetyRatings']:
+                                            if rating['probability'] == 'HIGH':
+                                                error_msg = f"模型的响应被截断: {rating['category']}"
+                                                extra_log_safety = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                                                log_msg = format_log_message('WARNING', error_msg, extra=extra_log_safety)
+                                                logger.warning(log_msg)
+                                                raise ValueError(error_msg)
+                            except json.JSONDecodeError:
+                                continue
+                            except Exception as e:
+                                error_msg = f"流式处理期间发生错误: {str(e)}"
+                                extra_log_stream_error = {'key': self.api_key[:8], 'request_type': 'stream', 'model': request.model, 'status_code': 'ERROR', 'error_message': error_msg}
+                                log_msg = format_log_message('ERROR', error_msg, extra=extra_log_stream_error)
+                                logger.error(log_msg)
+                                raise e
+                    except Exception as e:
+                        raise e
+                    finally:
+                        log_msg = format_log_message('INFO', "流式请求结束", extra=extra_log)
+                        logger.info(log_msg)
+
+    def complete_chat(self, request: ChatCompletionRequest, contents, safety_settings, system_instruction):
+        extra_log = {'key': self.api_key[:8], 'request_type': 'non-stream', 'model': request.model}
+        log('info', "非流式请求开始", extra=extra_log)
+        
+        api_version, data = self._prepare_request_data(request, contents, safety_settings, system_instruction)
+        model= request.model.removesuffix("-search")
+        url = f"https://generativelanguage.googleapis.com/{api_version}/models/{model}:generateContent?key={self.api_key}"
+        headers = {
+            "Content-Type": "application/json",
+        }
+        
+        try:
+            response = requests.post(url, headers=headers, json=data)
+            response.raise_for_status()
+            log('info', "非流式请求成功完成", extra=extra_log)
+            
+            return ResponseWrapper(response.json())
+        except Exception as e:
+            raise
+
+    def convert_messages(self, messages, use_system_prompt=False,model=None):
+        gemini_history = []
+        errors = []
+        system_instruction_text = ""
+        is_system_phase = use_system_prompt
+        for i, message in enumerate(messages):
+            role = message.role
+            content = message.content
+            if isinstance(content, str):
+                if is_system_phase and role == 'system':
+                    if system_instruction_text:
+                        system_instruction_text += "\n" + content
+                    else:
+                        system_instruction_text = content
+                else:
+                    is_system_phase = False
+
+                    if role in ['user', 'system']:
+                        role_to_use = 'user'
+                    elif role == 'assistant':
+                        role_to_use = 'model'
+                    else:
+                        errors.append(f"Invalid role: {role}")
+                        continue
+
+                    if gemini_history and gemini_history[-1]['role'] == role_to_use:
+                        gemini_history[-1]['parts'].append({"text": content})
+                    else:
+                        gemini_history.append(
+                            {"role": role_to_use, "parts": [{"text": content}]})
+            elif isinstance(content, list):
+                parts = []
+                for item in content:
+                    if item.get('type') == 'text':
+                        parts.append({"text": item.get('text')})
+                    elif item.get('type') == 'image_url':
+                        image_data = item.get('image_url', {}).get('url', '')
+                        if image_data.startswith('data:image/'):
+                            try:
+                                mime_type, base64_data = image_data.split(';')[0].split(':')[1], image_data.split(',')[1]
+                                parts.append({
+                                    "inline_data": {
+                                        "mime_type": mime_type,
+                                        "data": base64_data
+                                    }
+                                })
+                            except (IndexError, ValueError):
+                                errors.append(
+                                    f"Invalid data URI for image: {image_data}")
+                        else:
+                            errors.append(
+                                f"Invalid image URL format for item: {item}")
+
+                if parts:
+                    if role in ['user', 'system']:
+                        role_to_use = 'user'
+                    elif role == 'assistant':
+                        role_to_use = 'model'
+                    else:
+                        errors.append(f"Invalid role: {role}")
+                        continue
+                    if gemini_history and gemini_history[-1]['role'] == role_to_use:
+                        gemini_history[-1]['parts'].extend(parts)
+                    else:
+                        gemini_history.append(
+                            {"role": role_to_use, "parts": parts})
+        if errors:
+            return errors
+        else:
+            # 只有当search_mode为真且模型名称以-search结尾时，才添加搜索提示
+            if settings.serach["search_mode"] and model and model.endswith("-search"):
+                gemini_history.insert(len(gemini_history)-2,{'role': 'user', 'parts': [{'text':settings.serach["search_prompt"]}]})
+            if RANDOM_STRING:
+                gemini_history.insert(1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(RANDOM_STRING_LENGTH)}]})
+                gemini_history.insert(len(gemini_history)-1,{'role': 'user', 'parts': [{'text': generate_secure_random_string(RANDOM_STRING_LENGTH)}]})
+                log_msg = format_log_message('INFO', "伪装消息成功")
+            return gemini_history, {"parts": [{"text": system_instruction_text}]}
+
+    @staticmethod
+    async def list_available_models(api_key) -> list:
+        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(
+            api_key)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            data = response.json()
+            models = []
+            for model in data.get("models", []):
+                models.append(model["name"])
+                if model["name"].startswith("models/gemini-2"):
+                    models.append(model["name"] + "-search")
+            models.extend(GeminiClient.EXTRA_MODELS)
+                
+            return models

app/templates/__init__.py

@@ -0,0 +1 @@
+# Templates package initialization

app/templates/assets/index.css

@@ -0,0 +1 @@
+:root{--vt-c-white: #ffffff;--vt-c-white-soft: #f8f8f8;--vt-c-white-mute: #f2f2f2;--vt-c-black: #181818;--vt-c-black-soft: #222222;--vt-c-black-mute: #282828;--vt-c-indigo: #2c3e50;--vt-c-divider-light-1: rgba(60, 60, 60, .29);--vt-c-divider-light-2: rgba(60, 60, 60, .12);--vt-c-divider-dark-1: rgba(84, 84, 84, .65);--vt-c-divider-dark-2: rgba(84, 84, 84, .48);--vt-c-text-light-1: var(--vt-c-indigo);--vt-c-text-light-2: rgba(60, 60, 60, .66);--vt-c-text-dark-1: var(--vt-c-white);--vt-c-text-dark-2: rgba(235, 235, 235, .64)}:root{--color-background: var(--vt-c-white);--color-background-soft: var(--vt-c-white-soft);--color-background-mute: var(--vt-c-white-mute);--color-border: var(--vt-c-divider-light-2);--color-border-hover: var(--vt-c-divider-light-1);--color-heading: var(--vt-c-text-light-1);--color-text: var(--vt-c-text-light-1);--section-gap: 160px;--card-background: #ffffff;--card-border: #e0e0e0;--button-primary: #007bff;--button-primary-hover: #0069d9;--button-text: #ffffff;--stats-item-bg: #f8f9fa;--log-entry-bg: #f8f9fa;--log-entry-border: #e9ecef;--toggle-bg: #ccc;--toggle-active: #007bff}.dark-mode{--color-background: var(--vt-c-black);--color-background-soft: var(--vt-c-black-soft);--color-background-mute: var(--vt-c-black-mute);--color-border: var(--vt-c-divider-dark-2);--color-border-hover: var(--vt-c-divider-dark-1);--color-heading: var(--vt-c-text-dark-1);--color-text: var(--vt-c-text-dark-2);--card-background: #2d2d2d;--card-border: #444444;--button-primary: #0056b3;--button-primary-hover: #004494;--button-text: #ffffff;--stats-item-bg: #333333;--log-entry-bg: #333333;--log-entry-border: #444444;--toggle-bg: #555555;--toggle-active: #0056b3}@media (prefers-color-scheme: dark){:root:not(.dark-mode):not(.light-mode){--color-background: var(--vt-c-black);--color-background-soft: var(--vt-c-black-soft);--color-background-mute: var(--vt-c-black-mute);--color-border: var(--vt-c-divider-dark-2);--color-border-hover: var(--vt-c-divider-dark-1);--color-heading: var(--vt-c-text-dark-1);--color-text: var(--vt-c-text-dark-2);--card-background: #2d2d2d;--card-border: #444444;--button-primary: #0056b3;--button-primary-hover: #004494;--button-text: #ffffff;--stats-item-bg: #333333;--log-entry-bg: #333333;--log-entry-border: #444444;--toggle-bg: #555555;--toggle-active: #0056b3}}*,*:before,*:after{box-sizing:border-box;margin:0;font-weight:400}body{min-height:100vh;color:var(--color-text);background:var(--color-background);transition:color .5s,background-color .5s;line-height:1.6;font-family:Inter,-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Oxygen,Ubuntu,Cantarell,Fira Sans,Droid Sans,Helvetica Neue,sans-serif;font-size:15px;text-rendering:optimizeLegibility;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}#app{max-width:1280px;margin:0 auto;padding:1rem;font-weight:400}a,.green{text-decoration:none;color:#00bd7e;transition:.4s;padding:3px}@media (hover: hover){a:hover{background-color:#00bd7e33}}body{margin:0;padding:0}.info-box[data-v-ec28689b]{background-color:var(--card-background);border:1px solid var(--card-border);border-radius:8px;padding:20px;margin-bottom:20px;box-shadow:0 2px 4px #0000000d;transition:background-color .3s,border-color .3s,box-shadow .3s}@media (max-width: 768px){.info-box[data-v-ec28689b]{margin-bottom:12px}}@media (max-width: 480px){.info-box[data-v-ec28689b]{margin-bottom:8px}}.status[data-v-ec28689b]{color:#28a745;font-weight:700;font-size:18px;margin-bottom:20px;text-align:center}.section-title[data-v-ec28689b]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:color .3s,border-color .3s}.stats-grid[data-v-ec28689b]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px;margin-bottom:20px}@media (max-width: 768px){.stats-grid[data-v-ec28689b]{gap:6px}}.stat-card[data-v-ec28689b]{background-color:var(--stats-item-bg);padding:15px;border-radius:8px;text-align:center;box-shadow:0 2px 4px #0000000d;transition:transform .2s,background-color .3s,box-shadow .3s}.stat-card[data-v-ec28689b]:hover{transform:translateY(-2px);box-shadow:0 4px 8px #0000001a}.stat-value[data-v-ec28689b]{font-size:24px;font-weight:700;color:var(--button-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:color .3s}.stat-label[data-v-ec28689b]{font-size:14px;color:var(--color-text);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:color .3s}@media (max-width: 768px){.stat-card[data-v-ec28689b]{padding:8px 5px}.stat-value[data-v-ec28689b]{font-size:16px}.stat-label[data-v-ec28689b]{font-size:11px;margin-top:3px}}@media (max-width: 480px){.stat-card[data-v-ec28689b]{padding:6px 3px}.stat-value[data-v-ec28689b]{font-size:14px}.stat-label[data-v-ec28689b]{font-size:10px;margin-top:2px}}.api-key-stats-container[data-v-ec28689b]{margin-top:20px}.api-key-stats-list[data-v-ec28689b]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px}@media (max-width: 992px){.api-key-stats-list[data-v-ec28689b]{grid-template-columns:repeat(2,1fr)}}@media (max-width: 576px){.api-key-stats-list[data-v-ec28689b]{grid-template-columns:1fr}}.api-key-item[data-v-ec28689b]{background-color:var(--stats-item-bg);border-radius:8px;padding:15px;box-shadow:0 2px 4px #0000000d;transition:background-color .3s,box-shadow .3s}.api-key-header[data-v-ec28689b]{display:flex;justify-content:space-between;align-items:center;margin-bottom:10px}.api-key-name[data-v-ec28689b]{font-weight:700;color:var(--color-heading);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:50%;transition:color .3s}.api-key-usage[data-v-ec28689b]{display:flex;align-items:center;gap:10px;white-space:nowrap}.api-key-count[data-v-ec28689b]{font-weight:700;color:var(--button-primary);transition:color .3s}@media (max-width: 768px){.api-key-item[data-v-ec28689b]{padding:8px}.api-key-header[data-v-ec28689b]{margin-bottom:6px}.api-key-name[data-v-ec28689b]{font-size:12px}.api-key-usage[data-v-ec28689b]{font-size:12px;gap:5px}}@media (max-width: 480px){.api-key-item[data-v-ec28689b]{padding:6px}.api-key-name[data-v-ec28689b]{font-size:11px;max-width:45%}.api-key-usage[data-v-ec28689b]{font-size:11px;gap:3px}}.progress-container[data-v-ec28689b]{width:100%;height:10px;background-color:var(--color-background-soft);border-radius:5px;overflow:hidden;transition:background-color .3s}.progress-bar[data-v-ec28689b]{height:100%;border-radius:5px;transition:width .3s ease,background-color .3s}.progress-bar.low[data-v-ec28689b]{background-color:#28a745}.progress-bar.medium[data-v-ec28689b]{background-color:#ffc107}.progress-bar.high[data-v-ec28689b]{background-color:#dc3545}.model-stats-container[data-v-ec28689b]{margin-top:10px;border-top:1px dashed var(--color-border);padding-top:10px;transition:border-color .3s}.model-stats-header[data-v-ec28689b]{display:flex;justify-content:space-between;align-items:center;cursor:pointer;-webkit-user-select:none;user-select:none;margin-bottom:8px;color:var(--color-heading);font-size:14px;transition:color .3s}.model-stats-title[data-v-ec28689b]{font-weight:600}.model-stats-toggle[data-v-ec28689b]{font-size:12px}.model-stats-list[data-v-ec28689b]{display:flex;flex-direction:column;gap:8px}.model-stat-item[data-v-ec28689b]{display:flex;justify-content:space-between;align-items:center;padding:6px 10px;background-color:var(--color-background-mute);border-radius:4px;font-size:13px;transition:transform .2s,box-shadow .2s,background-color .3s}.model-name[data-v-ec28689b]{font-weight:500;color:var(--color-heading);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:60%;transition:color .3s}.model-count[data-v-ec28689b]{display:flex;align-items:center;gap:8px;color:var(--button-primary);font-weight:600;transition:color .3s}.model-usage-text[data-v-ec28689b]{color:var(--color-text);font-weight:400;font-size:12px;transition:color .3s}.model-progress-container[data-v-ec28689b]{width:60px;height:6px;background-color:var(--color-background-soft);border-radius:3px;overflow:hidden;margin-left:5px;transition:background-color .3s}.model-progress-bar[data-v-ec28689b]{height:100%;border-radius:3px;transition:width .3s ease,background-color .3s}.view-more-models[data-v-ec28689b]{text-align:center;color:var(--button-primary);font-size:12px;cursor:pointer;padding:8px;margin-top:5px;border-radius:4px;background-color:#007bff0d;transition:all .2s ease,color .3s,background-color .3s}.view-more-models[data-v-ec28689b]:hover{background-color:#007bff1a;transform:translateY(-1px);box-shadow:0 2px 5px #0000000d}.fold-header[data-v-ec28689b]{cursor:pointer;-webkit-user-select:none;user-select:none;display:flex;justify-content:space-between;align-items:center;transition:background-color .2s;border-radius:6px;padding:5px 8px}.fold-header[data-v-ec28689b]:hover{background-color:var(--color-background-mute)}.fold-icon[data-v-ec28689b]{display:inline-flex;align-items:center;justify-content:center;transition:transform .3s ease}.fold-icon.rotated[data-v-ec28689b]{transform:rotate(180deg)}.fold-content[data-v-ec28689b]{overflow:hidden}.fold-enter-active[data-v-ec28689b],.fold-leave-active[data-v-ec28689b]{transition:all .3s ease;max-height:1000px;opacity:1;overflow:hidden}.fold-enter-from[data-v-ec28689b],.fold-leave-to[data-v-ec28689b]{max-height:0;opacity:0;overflow:hidden}.model-stat-item[data-v-ec28689b]:hover{transform:translateY(-2px);box-shadow:0 2px 8px #0000000d}@media (max-width: 768px){.model-stats-container[data-v-ec28689b]{margin-top:8px;padding-top:8px}.model-stats-header[data-v-ec28689b]{font-size:12px;margin-bottom:6px}.model-stat-item[data-v-ec28689b]{padding:4px 8px;font-size:11px}.model-progress-container[data-v-ec28689b]{width:40px;height:4px}}.info-box[data-v-fda98e8f]{background-color:var(--card-background);border:1px solid var(--card-border);border-radius:8px;padding:20px;margin-bottom:20px;box-shadow:0 2px 4px #0000000d;transition:background-color .3s,border-color .3s,box-shadow .3s}@media (max-width: 768px){.info-box[data-v-fda98e8f]{margin-bottom:12px}}@media (max-width: 480px){.info-box[data-v-fda98e8f]{margin-bottom:8px}}.section-title[data-v-fda98e8f]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:color .3s,border-color .3s}.stats-grid[data-v-fda98e8f]{display:grid;grid-template-columns:repeat(3,1fr);gap:15px;margin-top:15px;margin-bottom:20px}@media (max-width: 768px){.stats-grid[data-v-fda98e8f]{gap:6px}}.stat-card[data-v-fda98e8f]{background-color:var(--stats-item-bg);padding:15px;border-radius:8px;text-align:center;box-shadow:0 2px 4px #0000000d;transition:transform .2s,background-color .3s,box-shadow .3s}.stat-card[data-v-fda98e8f]:hover{transform:translateY(-2px);box-shadow:0 4px 8px #0000001a}.stat-value[data-v-fda98e8f]{font-size:24px;font-weight:700;color:var(--button-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:color .3s}.stat-label[data-v-fda98e8f]{font-size:14px;color:var(--color-text);margin-top:5px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;transition:color .3s}@media (max-width: 768px){.stat-card[data-v-fda98e8f]{padding:8px 5px}.stat-value[data-v-fda98e8f]{font-size:16px}.stat-label[data-v-fda98e8f]{font-size:11px;margin-top:3px}}@media (max-width: 480px){.stat-card[data-v-fda98e8f]{padding:6px 3px}.stat-value[data-v-fda98e8f]{font-size:14px}.stat-label[data-v-fda98e8f]{font-size:10px;margin-top:2px}}.update-needed[data-v-fda98e8f]{color:#dc3545!important}.up-to-date[data-v-fda98e8f]{color:#28a745!important}.info-box[data-v-c3726400]{background-color:var(--card-background);border:1px solid var(--card-border);border-radius:8px;padding:20px;margin-bottom:20px;box-shadow:0 2px 4px #0000000d;transition:background-color .3s,border-color .3s,box-shadow .3s}@media (max-width: 768px){.info-box[data-v-c3726400]{margin-bottom:12px}}@media (max-width: 480px){.info-box[data-v-c3726400]{margin-bottom:8px}}.section-title[data-v-c3726400]{color:var(--color-heading);border-bottom:1px solid var(--color-border);padding-bottom:10px;margin-bottom:20px;transition:color .3s,border-color .3s}.log-filter[data-v-c3726400]{display:flex;justify-content:center;margin-bottom:15px;gap:10px;flex-wrap:wrap}.log-filter button[data-v-c3726400]{padding:5px 10px;border:1px solid var(--card-border);border-radius:4px;background-color:var(--stats-item-bg);color:var(--color-text);cursor:pointer;min-width:60px;transition:background-color .3s,color .3s,border-color .3s}.log-filter button.active[data-v-c3726400]{background-color:var(--button-primary);color:var(--button-text);border-color:var(--button-primary)}@media (max-width: 768px){.log-filter[data-v-c3726400]{gap:6px;margin-bottom:12px}.log-filter button[data-v-c3726400]{padding:4px 8px;font-size:12px;min-width:50px}}@media (max-width: 480px){.log-filter[data-v-c3726400]{gap:4px;margin-bottom:10px}.log-filter button[data-v-c3726400]{padding:3px 6px;font-size:11px;min-width:40px}}.log-container[data-v-c3726400]{background-color:var(--log-entry-bg);border:1px solid var(--log-entry-border);border-radius:8px;padding:15px;margin-top:20px;max-height:500px;overflow-y:auto;font-family:monospace;font-size:14px;line-height:1.5;transition:background-color .3s,border-color .3s}.log-entry[data-v-c3726400]{margin-bottom:8px;padding:8px;border-radius:4px;word-break:break-word;transition:background-color .3s,border-color .3s}.log-entry.INFO[data-v-c3726400]{background-color:#17a2b81a;border-left:4px solid #17a2b8}.log-entry.WARNING[data-v-c3726400]{background-color:#ffc1071a;border-left:4px solid #ffc107}.log-entry.ERROR[data-v-c3726400]{background-color:#dc35451a;border-left:4px solid #dc3545}.log-entry.DEBUG[data-v-c3726400]{background-color:#17a2b81a;border-left:4px solid #17a2b8}.log-timestamp[data-v-c3726400]{color:var(--color-text);font-size:12px;margin-right:10px;opacity:.8;transition:color .3s}.log-level[data-v-c3726400]{font-weight:700;margin-right:10px}.log-level.INFO[data-v-c3726400]{color:#17a2b8}.log-level.WARNING[data-v-c3726400]{color:#ffc107}.log-level.ERROR[data-v-c3726400]{color:#dc3545}.log-level.DEBUG[data-v-c3726400]{color:#17a2b8}.log-message[data-v-c3726400]{color:var(--color-text);transition:color .3s}@media (max-width: 768px){.log-container[data-v-c3726400]{padding:10px;font-size:13px}.log-entry[data-v-c3726400]{padding:6px;margin-bottom:6px}.log-timestamp[data-v-c3726400]{font-size:11px;display:block;margin-bottom:3px}}@media (max-width: 480px){.log-container[data-v-c3726400]{padding:8px;font-size:12px}.log-entry[data-v-c3726400]{padding:5px;margin-bottom:5px}.log-timestamp[data-v-c3726400]{font-size:10px}.log-level[data-v-c3726400]{margin-right:5px}}body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif;line-height:1.6;background-color:var(--color-background);color:var(--color-text);margin:0;padding:0;transition:background-color .3s,color .3s}.dashboard{max-width:1200px;margin:0 auto;padding:20px}.header-container{display:flex;justify-content:space-between;align-items:center;margin-bottom:20px}h1{color:var(--color-heading);margin:0;font-size:1.8rem}.theme-toggle{display:flex;align-items:center}.toggle-label{margin-left:8px;font-size:1.2rem}.switch{position:relative;display:inline-block;width:60px;height:30px}.switch input{opacity:0;width:0;height:0}.slider{position:absolute;cursor:pointer;top:0;left:0;right:0;bottom:0;background-color:var(--toggle-bg);transition:.4s}.slider:before{position:absolute;content:"";height:22px;width:22px;left:4px;bottom:4px;background-color:#fff;transition:.4s}input:checked+.slider{background-color:var(--toggle-active)}input:focus+.slider{box-shadow:0 0 1px var(--toggle-active)}input:checked+.slider:before{transform:translate(30px)}.slider.round{border-radius:34px}.slider.round:before{border-radius:50%}@media (max-width: 768px){.dashboard{padding:10px 8px}.header-container{flex-direction:row;justify-content:space-between;align-items:center;margin-bottom:15px}h1{font-size:1.4rem;text-align:left;margin-right:10px}}@media (max-width: 480px){.dashboard{padding:6px 4px}h1{font-size:1.2rem}.switch{width:50px;height:26px}.slider:before{height:18px;width:18px}input:checked+.slider:before{transform:translate(24px)}.toggle-label{margin-left:5px;font-size:1rem}}.refresh-button{display:block;margin:20px auto;padding:10px 20px;background-color:var(--button-primary);color:var(--button-text);border:none;border-radius:4px;font-size:16px;cursor:pointer;transition:background-color .2s}.refresh-button:hover{background-color:var(--button-primary-hover)}@media (max-width: 768px){:deep(.info-box){padding:10px 6px;margin-bottom:10px;border-radius:6px;background-color:var(--card-background);border:1px solid var(--card-border)}:deep(.section-title){font-size:1.1rem;margin-bottom:10px;padding-bottom:6px;color:var(--color-heading);border-bottom:1px solid var(--color-border)}:deep(.stats-grid){gap:5px;margin-top:10px;margin-bottom:15px}.refresh-button{margin:15px auto;padding:8px 16px;font-size:14px}}@media (max-width: 480px){:deep(.info-box){padding:8px 4px;margin-bottom:6px;border-radius:5px}:deep(.section-title){font-size:1rem;margin-bottom:8px;padding-bottom:4px}:deep(.stats-grid){gap:4px;margin-top:8px;margin-bottom:10px}.refresh-button{margin:10px auto;padding:6px 12px;font-size:13px}}

app/templates/assets/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>HAJIMI</title>
+    <script type="module" crossorigin src="/main.js"></script>
+    <link rel="stylesheet" crossorigin href="/index.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

app/templates/index.html

@@ -0,0 +1,15 @@
+
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/assets/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Gemini API 代理服务</title>
+    <script type="module" crossorigin src="/assets/main.js"></script>
+    <link rel="stylesheet" href="/assets/index.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

app/utils/__init__.py

@@ -0,0 +1,12 @@
+# Utils package initialization
+
+from app.utils.logging import logger, log_manager, format_log_message,log
+from app.utils.api_key import APIKeyManager, test_api_key
+from app.utils.error_handling import handle_gemini_error, translate_error, handle_api_error
+from app.utils.rate_limiting import protect_from_abuse
+from app.utils.cache import ResponseCacheManager, generate_cache_key, cache_response
+from app.utils.request import ActiveRequestsManager, check_client_disconnect
+from app.utils.stats import clean_expired_stats, update_api_call_stats
+from app.utils.response import create_chat_response, create_error_response, create_response, handle_exception
+from app.utils.version import check_version
+from app.utils.maintenance import handle_exception, schedule_cache_cleanup

app/utils/api_key.py

@@ -0,0 +1,88 @@
+import random
+import re
+import os
+import logging
+from datetime import datetime, timedelta
+from apscheduler.schedulers.background import BackgroundScheduler
+from app.utils.logging import format_log_message
+
+logger = logging.getLogger("my_logger")
+
+class APIKeyManager:
+    def __init__(self):
+        self.api_keys = re.findall(
+            r"AIzaSy[a-zA-Z0-9_-]{33}", os.environ.get('GEMINI_API_KEYS', ""))
+        self.key_stack = [] # 初始化密钥栈
+        self._reset_key_stack() # 初始化时创建随机密钥栈
+        # self.api_key_blacklist = set()
+        # self.api_key_blacklist_duration = 60
+        self.scheduler = BackgroundScheduler()
+        self.scheduler.start()
+        self.tried_keys_for_request = set()  # 用于跟踪当前请求尝试中已试过的 key
+
+    def _reset_key_stack(self):
+        """创建并随机化密钥栈"""
+        shuffled_keys = self.api_keys[:]  # 创建 api_keys 的副本以避免直接修改原列表
+        random.shuffle(shuffled_keys)
+        self.key_stack = shuffled_keys
+
+
+    def get_available_key(self):
+        """从栈顶获取密钥，若栈空则重新生成"""
+        while self.key_stack:
+            key = self.key_stack.pop()
+            # if key not in self.api_key_blacklist and key not in self.tried_keys_for_request:
+            if key not in self.tried_keys_for_request:
+                self.tried_keys_for_request.add(key)
+                return key
+
+        # 栈空，重新生成密钥栈
+        self._reset_key_stack() 
+
+        # 再次尝试从新栈中获取密钥 (迭代一次)
+        while self.key_stack:
+            key = self.key_stack.pop()
+            # if key not in self.api_key_blacklist and key not in self.tried_keys_for_request:
+            if key not in self.tried_keys_for_request:
+                self.tried_keys_for_request.add(key)
+                return key
+
+        if not self.api_keys:
+            log_msg = format_log_message('ERROR', "没有配置任何 API 密钥！")
+            logger.error(log_msg)
+            return None
+        
+        return None
+
+
+    def show_all_keys(self):
+        log_msg = format_log_message('INFO', f"当前可用API key个数: {len(self.api_keys)} ")
+        logger.info(log_msg)
+        for i, api_key in enumerate(self.api_keys):
+            log_msg = format_log_message('INFO', f"API Key{i}: {api_key[:8]}...{api_key[-3:]}")
+            logger.info(log_msg)
+
+    # def blacklist_key(self, key):
+    #     log_msg = format_log_message('WARNING', f"{key[:8]} → 暂时禁用 {self.api_key_blacklist_duration} 秒")
+    #     logger.warning(log_msg)
+    #     self.api_key_blacklist.add(key)
+    #     self.scheduler.add_job(lambda: self.api_key_blacklist.discard(key), 'date',
+    #                            run_date=datetime.now() + timedelta(seconds=self.api_key_blacklist_duration))
+
+    def reset_tried_keys_for_request(self):
+        """在新的请求尝试时重置已尝试的 key 集合"""
+        self.tried_keys_for_request = set()
+
+async def test_api_key(api_key: str) -> bool:
+    """
+    测试 API 密钥是否有效。
+    """
+    try:
+        import httpx
+        url = "https://generativelanguage.googleapis.com/v1beta/models?key={}".format(api_key)
+        async with httpx.AsyncClient() as client:
+            response = await client.get(url)
+            response.raise_for_status()
+            return True
+    except Exception:
+        return False

app/utils/cache.py

@@ -0,0 +1,137 @@
+import time
+import hashlib
+import json
+from typing import Dict, Any, Optional
+import logging
+from app.utils.logging import log
+from app.config.settings import (
+    api_call_stats
+)
+logger = logging.getLogger("my_logger")
+
+class ResponseCacheManager:
+    """管理API响应缓存的类"""
+    
+    def __init__(self, expiry_time: int, max_entries: int, remove_after_use: bool = True, 
+                cache_dict: Dict[str, Dict[str, Any]] = None):
+        self.cache = cache_dict if cache_dict is not None else {}  # 使用传入的缓存字典或创建新字典
+        self.expiry_time = expiry_time
+        self.max_entries = max_entries
+        self.remove_after_use = remove_after_use
+    
+    def get(self, cache_key: str):
+        """获取缓存项，如果存在且未过期"""
+        now = time.time()
+        if cache_key in self.cache and now < self.cache[cache_key].get('expiry_time', 0):
+            cached_item = self.cache[cache_key]
+            
+            # 获取响应但先不删除
+            response = cached_item['response']
+            
+            # 返回响应
+            return response, True
+        
+        return None, False
+    
+    def store(self, cache_key: str, response, client_ip: str = None):
+        """存储响应到缓存"""
+        now = time.time()
+        self.cache[cache_key] = {
+            'response': response,
+            'expiry_time': now + self.expiry_time,
+            'created_at': now,
+            'client_ip': client_ip
+        }
+        
+        log('info', f"响应已缓存: {cache_key[:8]}...", 
+            extra={'cache_operation': 'store', 'request_type': 'non-stream'})
+        
+        # 如果缓存超过限制，清理最旧的
+        self.clean_if_needed()
+    
+    def clean_expired(self):
+        """清理所有过期的缓存项"""
+        now = time.time()
+        expired_keys = [k for k, v in self.cache.items() if now > v.get('expiry_time', 0)]
+        
+        for key in expired_keys:
+            del self.cache[key]
+            log('info', f"清理过期缓存: {key[:8]}...", extra={'cache_operation': 'clean'})
+    
+    def clean_if_needed(self):
+        """如果缓存数量超过限制，清理最旧的项目"""
+        if len(self.cache) <= self.max_entries:
+            return
+        
+        # 按创建时间排序
+        sorted_keys = sorted(self.cache.keys(),
+                           key=lambda k: self.cache[k].get('created_at', 0))
+        
+        # 计算需要删除的数量
+        to_remove = len(self.cache) - self.max_entries
+        
+        # 删除最旧的项
+        for key in sorted_keys[:to_remove]:
+            del self.cache[key]
+            log('info', f"缓存容量限制，删除旧缓存: {key[:8]}...", extra={'cache_operation': 'limit'})
+
+def generate_cache_key(chat_request) -> str:
+    """生成请求的唯一缓存键"""
+    # 创建包含请求关键信息的字典
+    request_data = {
+        'model': chat_request.model, 
+        'messages': []
+    }
+    
+    # 添加消息内容
+    for msg in chat_request.messages:
+        if isinstance(msg.content, str):
+            message_data = {'role': msg.role, 'content': msg.content}
+            request_data['messages'].append(message_data)
+        elif isinstance(msg.content, list):
+            content_list = []
+            for item in msg.content:
+                if item.get('type') == 'text':
+                    content_list.append({'type': 'text', 'text': item.get('text')})
+                # 对于图像数据，我们只使用标识符而不是全部数据
+                elif item.get('type') == 'image_url':
+                    image_data = item.get('image_url', {}).get('url', '')
+                    if image_data.startswith('data:image/'):
+                        # 对于base64图像，使用前32字符作为标识符
+                        content_list.append({'type': 'image_url', 'hash': hashlib.md5(image_data[:32].encode()).hexdigest()})
+                    else:
+                        content_list.append({'type': 'image_url', 'url': image_data})
+            request_data['messages'].append({'role': msg.role, 'content': content_list})
+    
+    # 将字典转换为JSON字符串并计算哈希值
+    json_data = json.dumps(request_data, sort_keys=True)
+    return hashlib.md5(json_data.encode()).hexdigest()
+
+def cache_response(response, cache_key, client_ip, response_cache_manager, update_api_call_stats, endpoint=None,model=None):
+    """
+    将响应存入缓存
+    
+    参数:
+    - response: 响应对象
+    - cache_key: 缓存键
+    - client_ip: 客户端IP
+    - response_cache_manager: 缓存管理器
+    - update_api_call_stats: 更新统计的函数
+    - api_key: API密钥，用于更新API密钥使用统计
+    """
+    if not cache_key:
+        return
+        
+    # 先检查缓存是否已存在
+    existing_cache = cache_key in response_cache_manager.cache
+    
+    if existing_cache:
+        log('info', f"缓存已存在，跳��存储: {cache_key[:8]}...",
+            extra={'cache_operation': 'skip-existing', 'request_type': 'non-stream'})
+    else:
+        response_cache_manager.store(cache_key, response, client_ip)
+        log('info', f"API响应已缓存: {cache_key[:8]}...",
+            extra={'cache_operation': 'store-new', 'request_type': 'non-stream'})
+    
+    # 更新API调用统计
+    update_api_call_stats(api_call_stats,endpoint=endpoint,model=model)

app/utils/error_handling.py

@@ -0,0 +1,120 @@
+import requests
+import logging
+import asyncio
+from fastapi import HTTPException, status
+from app.utils.logging import format_log_message
+from app.utils.logging import log
+
+logger = logging.getLogger("my_logger")
+
+def handle_gemini_error(error, current_api_key, key_manager) -> str:
+    if isinstance(error, requests.exceptions.HTTPError):
+        status_code = error.response.status_code
+        if status_code == 400:
+            try:
+                error_data = error.response.json()
+                if 'error' in error_data:
+                    if error_data['error'].get('code') == "invalid_argument":
+                        error_message = "无效的 API 密钥"
+                        extra_log_invalid_key = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                        log_msg = format_log_message('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 无效，可能已过期或被删除", extra=extra_log_invalid_key)
+                        logger.error(log_msg)
+                        # key_manager.blacklist_key(current_api_key)
+                        
+                        return error_message
+                    error_message = error_data['error'].get(
+                        'message', 'Bad Request')
+                    extra_log_400 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                    log_msg = format_log_message('WARNING', f"400 错误请求: {error_message}", extra=extra_log_400)
+                    logger.warning(log_msg)
+                    return f"400 错误请求: {error_message}"
+            except ValueError:
+                error_message = "400 错误请求：响应不是有效的JSON格式"
+                extra_log_400_json = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+                log_msg = format_log_message('WARNING', error_message, extra=extra_log_400_json)
+                logger.warning(log_msg)
+                return error_message
+
+        elif status_code == 429:
+            error_message = "API 密钥配额已用尽或其他原因"
+            extra_log_429 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 429 官方资源耗尽或其他原因", extra=extra_log_429)
+            logger.warning(log_msg)
+            # key_manager.blacklist_key(current_api_key)
+             
+            return error_message
+
+        elif status_code == 403:
+            error_message = "权限被拒绝"
+            extra_log_403 = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('ERROR', f"{current_api_key[:8]} ... {current_api_key[-3:]} → 403 权限被拒绝", extra=extra_log_403)
+            logger.error(log_msg)
+            # key_manager.blacklist_key(current_api_key)
+            
+            return error_message
+        else:
+            error_message = f"未知错误: {status_code}"
+            extra_log_other = {'key': current_api_key[:8], 'status_code': status_code, 'error_message': error_message}
+            log_msg = format_log_message('WARNING', f"{current_api_key[:8]} ... {current_api_key[-3:]} → {status_code} 未知错误", extra=extra_log_other)
+            logger.warning(log_msg)
+            
+            return f"未知错误/模型不可用: {status_code}"
+
+    elif isinstance(error, requests.exceptions.ConnectionError):
+        error_message = "连接错误"
+        log_msg = format_log_message('WARNING', error_message, extra={'error_message': error_message})
+        logger.warning(log_msg)
+        return error_message
+
+    elif isinstance(error, requests.exceptions.Timeout):
+        error_message = "请求超时"
+        log_msg = format_log_message('WARNING', error_message, extra={'error_message': error_message})
+        logger.warning(log_msg)
+        return error_message
+    else:
+        error_message = f"发生未知错误: {error}"
+        log_msg = format_log_message('ERROR', error_message, extra={'error_message': error_message})
+        logger.error(log_msg)
+        return error_message
+
+def translate_error(message: str) -> str:
+    if "quota exceeded" in message.lower():
+        return "API 密钥配额已用尽"
+    if "invalid argument" in message.lower():
+        return "无效参数"
+    if "internal server error" in message.lower():
+        return "服务器内部错误"
+    if "service unavailable" in message.lower():
+        return "服务不可用"
+    return message
+
+async def handle_api_error(e: Exception, api_key: str, key_manager, request_type: str, model: str, retry_count: int = 0):
+    """统一处理API错误"""
+    
+    if isinstance(e, requests.exceptions.HTTPError) :
+        status_code = e.response.status_code
+        # 对500和503错误实现自动重试机制, 最多���试3次
+        if retry_count < 3 and (status_code == 500 or status_code == 503):
+            error_message = 'Gemini API 内部错误' if (status_code == 500) else "Gemini API 服务目前不可用"
+            
+            # 等待时间 : MIN_RETRY_DELAY=1, MAX_RETRY_DELAY=16
+            wait_time = min(1 * (2 ** retry_count), 16)  
+            log('warning', f"{error_message}，将等待{wait_time}秒后重试 ({retry_count+1}/3)", 
+                extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'status_code': int(status_code)})
+            
+            
+            # 等待后返回重试信号
+            await asyncio.sleep(wait_time)
+            return {'remove_cache': False}
+        
+        # 重试次数用尽，在日志中输出错误状态码
+        log('error', f"Gemini 服务器错误({status_code}), 且重试{retry_count}次后仍然失败", 
+            extra={'key': api_key[:8], 'request_type': request_type, 'model': model, 'status_code': int(status_code)})        
+        
+        # 不再切换密钥，向客户端抛出HTTP异常
+        raise HTTPException(status_code=int(status_code),
+                          detail=f"Gemini API 服务器错误({status_code})，请稍后重试")
+    
+    # 对于其他错误，返回切换密钥的信号，并输出错误信息到日志中
+    error_detail = handle_gemini_error(e, api_key, key_manager)
+    return {'should_switch_key': True, 'error': error_detail, 'remove_cache': True}

app/utils/logging.py

@@ -0,0 +1,72 @@
+import logging
+from datetime import datetime
+from collections import deque
+from threading import Lock
+
+DEBUG = False  # 可以从环境变量中获取
+
+LOG_FORMAT_DEBUG = '%(asctime)s - %(levelname)s - [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s - %(error_message)s'
+LOG_FORMAT_NORMAL = '[%(asctime)s] [%(levelname)s] [%(key)s]-%(request_type)s-[%(model)s]-%(status_code)s: %(message)s'
+
+# 配置 logger
+logger = logging.getLogger("my_logger")
+logger.setLevel(logging.DEBUG)
+
+# 控制台处理器
+console_handler = logging.StreamHandler()
+console_formatter = logging.Formatter('%(message)s')
+console_handler.setFormatter(console_formatter)
+logger.addHandler(console_handler)
+
+# 日志缓存，用于在网页上显示最近的日志
+class LogManager:
+    def __init__(self, max_logs=100):
+        self.logs = deque(maxlen=max_logs)  # 使用双端队列存储最近的日志
+        self.lock = Lock()
+    
+    def add_log(self, log_entry):
+        with self.lock:
+            self.logs.append(log_entry)
+    
+    def get_recent_logs(self, count=50):
+        with self.lock:
+            return list(self.logs)[-count:]
+
+# 创建日志管理器实例
+log_manager = LogManager()
+
+def format_log_message(level, message, extra=None):
+    extra = extra or {}
+    log_values = {
+        'asctime': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'levelname': level,
+        'key': extra.get('key', 'N/A'),
+        'request_type': extra.get('request_type', 'N/A'),
+        'model': extra.get('model', 'N/A'),
+        'status_code': extra.get('status_code', 'N/A'),
+        'error_message': extra.get('error_message', ''),
+        'message': message
+    }
+    log_format = LOG_FORMAT_DEBUG if DEBUG else LOG_FORMAT_NORMAL
+    formatted_log = log_format % log_values
+    
+    # 将格式化后的日志添加到日志管理器
+    log_entry = {
+        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'level': level,
+        'key': extra.get('key', 'N/A'),
+        'request_type': extra.get('request_type', 'N/A'),
+        'model': extra.get('model', 'N/A'),
+        'status_code': extra.get('status_code', 'N/A'),
+        'message': message,
+        'error_message': extra.get('error_message', ''),
+        'formatted': formatted_log
+    }
+    log_manager.add_log(log_entry)
+    
+    return formatted_log
+
+def log(level: str, message: str, **extra):
+    """简化日志记录的统一函数"""
+    msg = format_log_message(level.upper(), message, extra=extra)
+    getattr(logger, level.lower())(msg)

app/utils/maintenance.py

@@ -0,0 +1,96 @@
+import sys,asyncio
+#from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.schedulers.asyncio import AsyncIOScheduler  # 替换为异步调度器
+from app.utils.logging import log
+from app.utils.stats import clean_expired_stats
+from app.config import api_call_stats
+from app.utils import check_version
+from zoneinfo import ZoneInfo
+from app.config import settings
+def handle_exception(exc_type, exc_value, exc_traceback):
+    """
+    全局异常处理函数
+    
+    处理未捕获的异常，并记录到日志中
+    """
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.excepthook(exc_type, exc_value, exc_traceback)
+        return
+    from app.utils.error_handling import translate_error
+    error_message = translate_error(str(exc_value))
+    log('error', f"未捕获的异常: {error_message}", status_code=500, error_message=error_message)
+'''
+def schedule_cache_cleanup(response_cache_manager, active_requests_manager):
+    """
+    设置定期清理缓存和活跃请求的定时任务
+    顺便定时检查更新
+    Args:
+        response_cache_manager: 响应缓存管理器实例
+        active_requests_manager: 活跃请求管理器实例
+    """
+    scheduler = BackgroundScheduler()
+    scheduler.add_job(response_cache_manager.clean_expired, 'interval', minutes=1)  # 每分钟清理过期缓存
+    scheduler.add_job(active_requests_manager.clean_completed, 'interval', seconds=30)  # 每30秒清理已完成的活跃请求
+    scheduler.add_job(active_requests_manager.clean_long_running, 'interval', minutes=5, args=[300])  # 每5分钟清理运行超过5分钟的任务
+    scheduler.add_job(clean_expired_stats, 'interval', minutes=5,args=[api_call_stats])  # 每5分钟清理过期的统计数据
+    scheduler.add_job(check_version, 'interval', minutes=1)  # 每4小时检查更新
+    scheduler.start()
+    
+    return scheduler
+
+'''
+def schedule_cache_cleanup(response_cache_manager, active_requests_manager):
+    """
+    设置定期清理缓存和活跃请求的定时任务
+    顺便定时检查更新
+    Args:
+        response_cache_manager: 响应缓存管理器实例
+        active_requests_manager: 活跃请求管理器实例
+    """
+    beijing_tz = ZoneInfo("Asia/Shanghai")
+    scheduler = AsyncIOScheduler(timezone=beijing_tz)  # 使用 AsyncIOScheduler 替代 BackgroundScheduler
+    
+    # 添加任务时直接传递异步函数（无需额外包装）
+    scheduler.add_job(response_cache_manager.clean_expired, 'interval', minutes=1)
+    scheduler.add_job(active_requests_manager.clean_completed, 'interval', seconds=30)
+    scheduler.add_job(active_requests_manager.clean_long_running, 'interval', minutes=5, args=[300])
+    scheduler.add_job(clean_expired_stats, 'interval', minutes=5, args=[api_call_stats])
+    scheduler.add_job(check_version, 'interval', hours=4)
+    scheduler.add_job(api_call_stats_clean, 'cron', hour=16,minute=0)  # 每天16:00清理统计数据
+    scheduler.start()
+    return scheduler
+
+async def api_call_stats_clean():
+    """
+    每天定时重置API调用统计数据
+    
+    将settings.api_call_stats重置为初始空结构
+    """
+    from app.utils.logging import log
+    
+    # 清空原字典中的数据，而不是重新赋值
+    settings.api_call_stats['last_24h']['total'].clear()
+    settings.api_call_stats['last_24h']['by_endpoint'].clear()
+    settings.api_call_stats['hourly']['total'].clear()
+    settings.api_call_stats['hourly']['by_endpoint'].clear()
+    settings.api_call_stats['minute']['total'].clear()
+    settings.api_call_stats['minute']['by_endpoint'].clear()
+    
+    # 重新初始化结构
+    settings.api_call_stats = {
+        'last_24h': {
+            'total': {},
+            'by_endpoint': {}
+        },
+        'hourly': {
+            'total': {},
+            'by_endpoint': {}
+        },
+        'minute': {
+            'total': {},
+            'by_endpoint': {}
+        }
+    }
+    
+    # 记录日志，确认函数被执行
+    log('info', "API调用统计数据已重置")

app/utils/rate_limiting.py

@@ -0,0 +1,36 @@
+import time
+from threading import Lock
+from fastapi import HTTPException, Request
+
+rate_limit_data = {}
+rate_limit_lock = Lock()
+
+def protect_from_abuse(request: Request, max_requests_per_minute: int = 30, max_requests_per_day_per_ip: int = 600):
+    now = int(time.time())
+    minute = now // 60
+    day = now // (60 * 60 * 24)
+
+    minute_key = f"{request.url.path}:{minute}"
+    day_key = f"{request.client.host}:{day}"
+
+    with rate_limit_lock:
+        minute_count, minute_timestamp = rate_limit_data.get(
+            minute_key, (0, now))
+        if now - minute_timestamp >= 60:
+            minute_count = 0
+            minute_timestamp = now
+        minute_count += 1
+        rate_limit_data[minute_key] = (minute_count, minute_timestamp)
+
+        day_count, day_timestamp = rate_limit_data.get(day_key, (0, now))
+        if now - day_timestamp >= 86400:
+            day_count = 0
+            day_timestamp = now
+        day_count += 1
+        rate_limit_data[day_key] = (day_count, day_timestamp)
+
+    if minute_count > max_requests_per_minute:
+        raise HTTPException(status_code=429, detail={
+            "message": "Too many requests per minute", "limit": max_requests_per_minute})
+    if day_count > max_requests_per_day_per_ip:
+        raise HTTPException(status_code=429, detail={"message": "Too many requests per day from this IP", "limit": max_requests_per_day_per_ip})

app/utils/request.py

@@ -0,0 +1,72 @@
+import asyncio
+import time
+from typing import Dict, Any
+from app.utils.logging import log
+
+class ActiveRequestsManager:
+    """管理活跃API请求的类"""
+    
+    def __init__(self, requests_pool: Dict[str, asyncio.Task] = None):
+        self.active_requests = requests_pool if requests_pool is not None else {}  # 存储活跃请求
+    
+    def add(self, key: str, task: asyncio.Task):
+        """添加新的活跃请求任务"""
+        task.creation_time = time.time()  # 添加创建时间属性
+        self.active_requests[key] = task
+    
+    def get(self, key: str):
+        """获取活跃请求任务"""
+        return self.active_requests.get(key)
+    
+    def remove(self, key: str):
+        """移除活跃请求任务"""
+        if key in self.active_requests:
+            del self.active_requests[key]
+            return True
+        return False
+    
+    def remove_by_prefix(self, prefix: str):
+        """移除所有以特定前缀开头的活跃请求任务"""
+        keys_to_remove = [k for k in self.active_requests.keys() if k.startswith(prefix)]
+        for key in keys_to_remove:
+            self.remove(key)
+        return len(keys_to_remove)
+    
+    def clean_completed(self):
+        """清理所有已完成或已取消的任务"""
+        keys_to_remove = []
+        
+        for key, task in self.active_requests.items():
+            if task.done() or task.cancelled():
+                keys_to_remove.append(key)
+        
+        for key in keys_to_remove:
+            self.remove(key)
+        
+        # if keys_to_remove:
+        #    log('info', f"清理已完成请求任务: {len(keys_to_remove)}个", cleanup='active_requests')
+    
+    def clean_long_running(self, max_age_seconds: int = 300):
+        """清理长时间运行的任务"""
+        now = time.time()
+        long_running_keys = []
+        
+        for key, task in list(self.active_requests.items()):
+            if (hasattr(task, 'creation_time') and
+                task.creation_time < now - max_age_seconds and
+                not task.done() and not task.cancelled()):
+                
+                long_running_keys.append(key)
+                task.cancel()  # 取消长时间运行的任务
+        
+        if long_running_keys:
+            log('warning', f"取消长时间运行的任务: {len(long_running_keys)}个", cleanup='long_running_tasks')
+
+async def check_client_disconnect(http_request, current_api_key: str, request_type: str, model: str):
+    """检查客户端是否断开连接"""
+    while True:
+        if await http_request.is_disconnected():
+            extra_log = {'key': current_api_key[:8], 'request_type': request_type, 'model': model, 'error_message': '检测到客户端断开连接'}
+            log('info', "客户端连接已中断，等待API请求完成", extra=extra_log)
+            return True
+        await asyncio.sleep(0.5)

app/utils/response.py

@@ -0,0 +1,59 @@
+import time
+from fastapi import status
+from fastapi.responses import JSONResponse
+
+def create_chat_response(model: str, choices: list, id: str = None):
+    """创建标准响应对象的工厂函数"""
+    return {
+        "id": id or f"chatcmpl-{int(time.time()*1000)}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model,
+        "choices": choices,
+        "usage": {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0
+        }
+    }
+
+def create_error_response(model: str, error_message: str):
+    """创建错误响应对象的工厂函数"""
+    return create_chat_response(
+        model=model,
+        choices=[{
+            "index": 0,
+            "message": {
+                "role": "assistant",
+                "content": error_message
+            },
+            "finish_reason": "error"
+        }]
+    )
+
+def create_response(chat_request, response_content):
+    """创建标准响应对象但不缓存"""
+    # 创建响应对象
+    return create_chat_response(
+        model=chat_request.model,
+        choices=[{
+            "index": 0, 
+            "message": {
+                "role": "assistant", 
+                "content": response_content.text
+            }, 
+            "finish_reason": "stop"
+        }]
+    )
+
+def handle_exception(exc_type, exc_value, exc_traceback, translate_error, log):
+    """处理全局异常的函数"""
+    if issubclass(exc_type, KeyboardInterrupt):
+        # 对于KeyboardInterrupt，使用默认处理
+        import sys
+        sys.excepthook(exc_type, exc_value, exc_traceback)
+        return
+    
+    # 对于其他异常，记录日志
+    error_message = translate_error(str(exc_value))
+    log('error', f"未捕获的异常: {error_message}", status_code=500, error_message=error_message)

app/utils/stats.py

@@ -0,0 +1,185 @@
+from datetime import datetime, timedelta
+from app.utils.logging import log
+
+def clean_expired_stats(api_call_stats):
+    """清理过期统计数据的函数"""
+    now = datetime.now()
+    
+    # 清理24小时前的数据
+    # 清理总调用次数
+    for hour_key in list(api_call_stats['last_24h']['total'].keys()):
+        try:
+            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+            if (now - hour_time).total_seconds() > 24 * 3600:  # 超过24小时
+                del api_call_stats['last_24h']['total'][hour_key]
+        except ValueError:
+            # 如果键格式不正确，直接删除
+            del api_call_stats['last_24h']['total'][hour_key]
+    
+    # 清理按端点和模型分类的数据
+    for endpoint in list(api_call_stats['last_24h']['by_endpoint'].keys()):
+        if not isinstance(api_call_stats['last_24h']['by_endpoint'][endpoint], dict):
+            del api_call_stats['last_24h']['by_endpoint'][endpoint]
+            continue
+            
+        for model in list(api_call_stats['last_24h']['by_endpoint'][endpoint].keys()):
+            if not isinstance(api_call_stats['last_24h']['by_endpoint'][endpoint][model], dict):
+                del api_call_stats['last_24h']['by_endpoint'][endpoint][model]
+                continue
+                
+            for hour_key in list(api_call_stats['last_24h']['by_endpoint'][endpoint][model].keys()):
+                try:
+                    hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+                    if (now - hour_time).total_seconds() > 24 * 3600:  # 超过24小时
+                        del api_call_stats['last_24h']['by_endpoint'][endpoint][model][hour_key]
+                except ValueError:
+                    # 如果键格式不正确，直接删除
+                    del api_call_stats['last_24h']['by_endpoint'][endpoint][model][hour_key]
+    
+    # 清理一小时前的小时统计数据
+    one_hour_ago = now - timedelta(hours=1)
+    # 清理总调用次数
+    for hour_key in list(api_call_stats['hourly']['total'].keys()):
+        try:
+            hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+            if hour_time < one_hour_ago:
+                del api_call_stats['hourly']['total'][hour_key]
+        except ValueError:
+            # 如果键格式不正确，直接删除
+            del api_call_stats['hourly']['total'][hour_key]
+    
+    # 清理按端点和模型分类的数据
+    for endpoint in list(api_call_stats['hourly']['by_endpoint'].keys()):
+        if not isinstance(api_call_stats['hourly']['by_endpoint'][endpoint], dict):
+            del api_call_stats['hourly']['by_endpoint'][endpoint]
+            continue
+            
+        for model in list(api_call_stats['hourly']['by_endpoint'][endpoint].keys()):
+            if not isinstance(api_call_stats['hourly']['by_endpoint'][endpoint][model], dict):
+                del api_call_stats['hourly']['by_endpoint'][endpoint][model]
+                continue
+                
+            for hour_key in list(api_call_stats['hourly']['by_endpoint'][endpoint][model].keys()):
+                try:
+                    hour_time = datetime.strptime(hour_key, '%Y-%m-%d %H:00')
+                    if hour_time < one_hour_ago:
+                        del api_call_stats['hourly']['by_endpoint'][endpoint][model][hour_key]
+                except ValueError:
+                    # 如果键格式不正确，直接删除
+                    del api_call_stats['hourly']['by_endpoint'][endpoint][model][hour_key]
+    
+    # 清理一分钟前的分钟统计数据
+    one_minute_ago = now - timedelta(minutes=1)
+    # 清理总调用次数
+    for minute_key in list(api_call_stats['minute']['total'].keys()):
+        try:
+            minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
+            if minute_time < one_minute_ago:
+                del api_call_stats['minute']['total'][minute_key]
+        except ValueError:
+            # 如果键格式不正确，直接删除
+            del api_call_stats['minute']['total'][minute_key]
+    
+    # 清理按端点和模型分类的数据
+    for endpoint in list(api_call_stats['minute']['by_endpoint'].keys()):
+        if not isinstance(api_call_stats['minute']['by_endpoint'][endpoint], dict):
+            del api_call_stats['minute']['by_endpoint'][endpoint]
+            continue
+            
+        for model in list(api_call_stats['minute']['by_endpoint'][endpoint].keys()):
+            if not isinstance(api_call_stats['minute']['by_endpoint'][endpoint][model], dict):
+                del api_call_stats['minute']['by_endpoint'][endpoint][model]
+                continue
+                
+            for minute_key in list(api_call_stats['minute']['by_endpoint'][endpoint][model].keys()):
+                try:
+                    minute_time = datetime.strptime(minute_key, '%Y-%m-%d %H:%M')
+                    if minute_time < one_minute_ago:
+                        del api_call_stats['minute']['by_endpoint'][endpoint][model][minute_key]
+                except ValueError:
+                    # 如果键格式不正确，直接删除
+                    del api_call_stats['minute']['by_endpoint'][endpoint][model][minute_key]
+
+def update_api_call_stats(api_call_stats, endpoint=None, model=None):
+    """
+    更新API调用统计的函数
+    
+    参数:
+    - api_call_stats: 统计数据字典
+    - endpoint: API端点,为None则只更新总调用次数
+    - model: 模型名称,与endpoint一起使用来分类统计数据
+    """
+    now = datetime.now()
+    hour_key = now.strftime('%Y-%m-%d %H:00')
+    minute_key = now.strftime('%Y-%m-%d %H:%M')
+    
+    # 检查并清理过期统计
+    clean_expired_stats(api_call_stats)
+    
+    # 初始化总调用次数键（如果不存在）
+    if hour_key not in api_call_stats['last_24h']['total']:
+        api_call_stats['last_24h']['total'][hour_key] = 0
+    if hour_key not in api_call_stats['hourly']['total']:
+        api_call_stats['hourly']['total'][hour_key] = 0
+    if minute_key not in api_call_stats['minute']['total']:
+        api_call_stats['minute']['total'][minute_key] = 0
+    
+    # 更新总调用次数统计
+    api_call_stats['last_24h']['total'][hour_key] += 1
+    api_call_stats['hourly']['total'][hour_key] += 1
+    api_call_stats['minute']['total'][minute_key] += 1
+    
+    # 如果提供了端点，更新按端点分类的统计
+    if endpoint and model:
+        # 确保端点字典存在
+        for period in ['last_24h', 'hourly', 'minute']:
+            if endpoint not in api_call_stats[period]['by_endpoint']:
+                api_call_stats[period]['by_endpoint'][endpoint] = {}
+            
+            if model not in api_call_stats[period]['by_endpoint'][endpoint]:
+                api_call_stats[period]['by_endpoint'][endpoint][model] = {}
+        
+        # 初始化端点和模型特定的时间键（如果不存在）
+        if hour_key not in api_call_stats['last_24h']['by_endpoint'][endpoint][model]:
+            api_call_stats['last_24h']['by_endpoint'][endpoint][model][hour_key] = 0
+            
+        if hour_key not in api_call_stats['hourly']['by_endpoint'][endpoint][model]:
+            api_call_stats['hourly']['by_endpoint'][endpoint][model][hour_key] = 0
+            
+        if minute_key not in api_call_stats['minute']['by_endpoint'][endpoint][model]:
+            api_call_stats['minute']['by_endpoint'][endpoint][model][minute_key] = 0
+        
+        # 更新端点特定的统计
+        if model is not None:
+            api_call_stats['last_24h']['by_endpoint'][endpoint][model][hour_key] += 1
+            api_call_stats['hourly']['by_endpoint'][endpoint][model][hour_key] += 1
+            api_call_stats['minute']['by_endpoint'][endpoint][model][minute_key] += 1
+    
+    # 计算总调用次数
+    total_24h = sum(api_call_stats['last_24h']['total'].values())
+    total_hourly = sum(api_call_stats['hourly']['total'].values())
+    total_minute = sum(api_call_stats['minute']['total'].values())
+    
+    log_message = "API调用统计已更新: 24小时=%s, 1小时=%s, 1分钟=%s" % (
+        total_24h, total_hourly, total_minute
+    )
+    
+    # 如果提供了端点和模型，添加端点特定的统计信息
+    if endpoint and model is not None:
+        try:
+            endpoint_24h = sum(api_call_stats['last_24h']['by_endpoint'][endpoint][model].values())
+            endpoint_hourly = sum(api_call_stats['hourly']['by_endpoint'][endpoint][model].values())
+            endpoint_minute = sum(api_call_stats['minute']['by_endpoint'][endpoint][model].values())
+            
+            log_message += " | 端点 '%s' 模型 '%s': 24小时=%s, 1小时=%s, 1分钟=%s" % (
+                endpoint[:8], model[:8], endpoint_24h, endpoint_hourly, endpoint_minute
+            )
+        except (KeyError, TypeError):
+            # 如果统计数据结构中缺少某些键，记录基本信息
+            log_message += " | 端点 '%s' 模型 '%s': 统计数据不完整" % (
+                endpoint[:8], model[:8]
+            )
+    else:
+        log_message += " | 端点 '%s' 模型 '%s': 统计数据不完整" 
+    
+    log('info', log_message)

app/utils/version.py

@@ -0,0 +1,49 @@
+import requests
+import logging
+from app.utils.logging import log
+import app.config.settings as settings
+async def check_version():
+    """
+    检查应用程序版本更新
+    
+    从本地和远程获取版本信息，并比较版本号以确定是否有更新
+    """
+    # 导入全局变量
+    try:
+        # 读取本地版本
+        with open("./version.txt", "r") as f:
+            version_line = f.read().strip()
+            settings.version['local_version'] = version_line.split("=")[1] if "=" in version_line else "0.0.0"
+        
+        # 获取远程版本
+        github_url = "https://raw.githubusercontent.com/wyeeeee/hajimi/refs/heads/main/version.txt"
+        response = requests.get(github_url, timeout=5)
+        if response.status_code == 200:
+            version_line = response.text.strip()
+            settings.version['remote_version']= version_line.split("=")[1] if "=" in version_line else "0.0.0"
+            # 比较版本号
+            local_parts = [int(x) for x in settings.version['local_version'].split(".")]
+            remote_parts = [int(x) for x in settings.version['remote_version'].split(".")]
+            
+            # 确保两个列表长度相同
+            while len(local_parts) < len(remote_parts):
+                local_parts.append(0)
+            while len(remote_parts) < len(local_parts):
+                remote_parts.append(0)
+                
+            # 比较版本号
+            settings.version['has_update'] = False
+            for i in range(len(local_parts)):
+                if remote_parts[i] > local_parts[i]:
+                    settings.version['has_update'] = True
+                    break
+                elif remote_parts[i] < local_parts[i]:
+                    break
+            
+            log('info', f"版本检查: 本地版本 {settings.version['local_version']}, 远程版本 {settings.version['remote_version']}, 有更新: {settings.version['has_update']}")
+        else:
+            log('warning', f"无法获取远程版本信息，HTTP状态码: {response.status_code}")
+    except Exception as e:
+        log('error', f"版本检查失败: {str(e)}")
+        
+    return settings.version['has_update']

hajimiUI/.gitignore

@@ -0,0 +1,30 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+.DS_Store
+dist
+dist-ssr
+coverage
+*.local
+
+/cypress/videos/
+/cypress/screenshots/
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+*.tsbuildinfo

hajimiUI/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar"]
+}

hajimiUI/README.md

@@ -0,0 +1,29 @@
+# hajimiUI
+
+This template should help get you started developing with Vue 3 in Vite.
+
+## Recommended IDE Setup
+
+[VSCode](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur).
+
+## Customize configuration
+
+See [Vite Configuration Reference](https://vite.dev/config/).
+
+## Project Setup
+
+```sh
+npm install
+```
+
+### Compile and Hot-Reload for Development
+
+```sh
+npm run dev
+```
+
+### Compile and Minify for Production
+
+```sh
+npm run build
+```

hajimiUI/build.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+// 获取 __dirname 等效值
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 确保目标目录存在
+const templatesDir = path.resolve(__dirname, '../app/templates');
+const assetsDir = path.resolve(templatesDir, 'assets');
+
+if (!fs.existsSync(templatesDir)) {
+  fs.mkdirSync(templatesDir, { recursive: true });
+}
+
+if (!fs.existsSync(assetsDir)) {
+  fs.mkdirSync(assetsDir, { recursive: true });
+}
+
+// 构建 Vue 应用
+console.log('正在构建 Vue 应用...');
+execSync('npm run build', { stdio: 'inherit' });
+
+// 检查生成的 CSS 文件名
+const cssFiles = fs.readdirSync(assetsDir).filter(file => file.endsWith('.css'));
+const cssFileName = cssFiles.length > 0 ? cssFiles[0] : 'index.css';
+
+console.log(`检测到 CSS 文件: ${cssFileName}`);
+
+// 创建一个简单的 index.html 文件，引用构建后的资源
+const indexContent = `
+<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/assets/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Gemini API 代理服务</title>
+    <script type="module" crossorigin src="/assets/main.js"></script>
+    <link rel="stylesheet" href="/assets/${cssFileName}">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>
+`;
+
+// 将 index.html 写入到 app/templates 目录
+const targetIndexPath = path.resolve(templatesDir, 'index.html');
+fs.writeFileSync(targetIndexPath, indexContent);
+
+console.log('构建完成！');
+console.log(`- index.html 已创建到: ${targetIndexPath}`);
+console.log(`- 静态资源已输出到: ${assetsDir}`);

hajimiUI/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>HAJIMI</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>

hajimiUI/jsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "exclude": ["node_modules", "dist"]
+}

hajimiUI/package-lock.json

@@ -0,0 +1,2812 @@
+{
+  "name": "hajimiui",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "hajimiui",
+      "version": "0.0.0",
+      "dependencies": {
+        "hajimiui": "file:",
+        "pinia": "^3.0.1",
+        "vue": "^3.5.13",
+        "vue-router": "^4.5.0"
+      },
+      "devDependencies": {
+        "@vitejs/plugin-vue": "^5.2.3",
+        "vite": "^6.2.4",
+        "vite-plugin-vue-devtools": "^7.7.2"
+      }
+    },
+    "node_modules/@ampproject/remapping": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
+      "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@antfu/utils": {
+      "version": "0.7.10",
+      "resolved": "https://registry.npmjs.org/@antfu/utils/-/utils-0.7.10.tgz",
+      "integrity": "sha512-+562v9k4aI80m1+VuMHehNJWLOFjBnXn3tdOitzD0il5b7smkSBal4+a3oKiQTbrwMmN/TBUMDvbdoWDehgOww==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.26.2",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
+      "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.25.9",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.26.8",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.8.tgz",
+      "integrity": "sha512-oH5UPLMWR3L2wEFLnFJ1TZXqHufiTKAiLfqw5zkhS4dKXLJ10yVztfil/twG8EDTA4F/tvVNw9nOl4ZMslB8rQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.26.10",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.26.10.tgz",
+      "integrity": "sha512-vMqyb7XCDMPvJFFOaT9kxtiRh42GwlZEg1/uIgtZshS5a/8OaduUfCi7kynKgc3Tw/6Uo2D+db9qBttghhmxwQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@ampproject/remapping": "^2.2.0",
+        "@babel/code-frame": "^7.26.2",
+        "@babel/generator": "^7.26.10",
+        "@babel/helper-compilation-targets": "^7.26.5",
+        "@babel/helper-module-transforms": "^7.26.0",
+        "@babel/helpers": "^7.26.10",
+        "@babel/parser": "^7.26.10",
+        "@babel/template": "^7.26.9",
+        "@babel/traverse": "^7.26.10",
+        "@babel/types": "^7.26.10",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.27.0.tgz",
+      "integrity": "sha512-VybsKvpiN1gU1sdMZIp7FcqphVVKEwcuj02x73uvcHE0PTihx1nlBcowYWhDwjpoAXRv43+gDzyggGnn1XZhVw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.27.0",
+        "@babel/types": "^7.27.0",
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-annotate-as-pure": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.25.9.tgz",
+      "integrity": "sha512-gv7320KBUFJz1RnylIg5WWYPRXKZ884AGkYpgpWW02TH66Dl+HaC1t1CKd0z3R4b6hdYEcmrNZHUmfCP+1u3/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.0.tgz",
+      "integrity": "sha512-LVk7fbXml0H2xH34dFzKQ7TDZ2G4/rVTOrq9V+icbbadjbVxxeFeDsNHv2SrZeWoA+6ZiTyWYWtScEIW07EAcA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.26.8",
+        "@babel/helper-validator-option": "^7.25.9",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-create-class-features-plugin": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.27.0.tgz",
+      "integrity": "sha512-vSGCvMecvFCd/BdpGlhpXYNhhC4ccxyvQWpbGL4CWbvfEoLFWUZuSuf7s9Aw70flgQF+6vptvgK2IfOnKlRmBg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.25.9",
+        "@babel/helper-member-expression-to-functions": "^7.25.9",
+        "@babel/helper-optimise-call-expression": "^7.25.9",
+        "@babel/helper-replace-supers": "^7.26.5",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9",
+        "@babel/traverse": "^7.27.0",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-member-expression-to-functions": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz",
+      "integrity": "sha512-wbfdZ9w5vk0C0oyHqAJbc62+vet5prjj01jjJ8sKn3j9h3MQQlflEdXYvuqRWjHnM12coDEqiC1IRCi0U/EKwQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.25.9",
+        "@babel/types": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.25.9.tgz",
+      "integrity": "sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.25.9",
+        "@babel/types": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.26.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.26.0.tgz",
+      "integrity": "sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9",
+        "@babel/traverse": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-optimise-call-expression": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.25.9.tgz",
+      "integrity": "sha512-FIpuNaz5ow8VyrYcnXQTDRGvV6tTjkNtCK/RYNDXGSLlUD6cBuQTSw43CShGxjvfBTfcUA/r6UhUCbtYqkhcuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.26.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.26.5.tgz",
+      "integrity": "sha512-RS+jZcRdZdRFzMyr+wcsaqOmld1/EqTghfaBGQQd/WnRdzdlvSZ//kF7U8VQTxf1ynZ4cjUcYgjVGx13ewNPMg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-replace-supers": {
+      "version": "7.26.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.26.5.tgz",
+      "integrity": "sha512-bJ6iIVdYX1YooY2X7w1q6VITt+LnUILtNk7zT78ykuwStx8BauCzxvFqFaHjOpW1bVnSUM1PN1f0p5P21wHxvg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-member-expression-to-functions": "^7.25.9",
+        "@babel/helper-optimise-call-expression": "^7.25.9",
+        "@babel/traverse": "^7.26.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz",
+      "integrity": "sha512-K4Du3BFa3gvyhzgPcntrkDgZzQaq6uozzcpGbOO1OEJaI+EJdqWIMTLgFgQf6lrfiDFo5FU+BxKepI9RmZqahA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.25.9",
+        "@babel/types": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.25.9.tgz",
+      "integrity": "sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.0.tgz",
+      "integrity": "sha512-U5eyP/CTFPuNE3qk+WZMxFkp/4zUzdceQlfzf7DdGdhp+Fezd7HD+i8Y24ZuTMKX3wQBld449jijbGq6OdGNQg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.27.0",
+        "@babel/types": "^7.27.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.0.tgz",
+      "integrity": "sha512-iaepho73/2Pz7w2eMS0Q5f83+0RKI7i4xmiYeBmDzfRVbQtTOG7Ts0S4HzJVsTMGI9keU8rNfuZr8DKfSt7Yyg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.27.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-proposal-decorators": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.25.9.tgz",
+      "integrity": "sha512-smkNLL/O1ezy9Nhy4CNosc4Va+1wo5w4gzSZeLe6y6dM4mmHfYOCPolXQPHQxonZCF+ZyebxN9vqOolkYrSn5g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-create-class-features-plugin": "^7.25.9",
+        "@babel/helper-plugin-utils": "^7.25.9",
+        "@babel/plugin-syntax-decorators": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-decorators": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.25.9.tgz",
+      "integrity": "sha512-ryzI0McXUPJnRCvMo4lumIKZUzhYUO/ScI+Mz4YVaTLt04DHNSjEUjKVvbzQjZFLuod/cYEc07mJWhzl6v4DPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-import-attributes": {
+      "version": "7.26.0",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.26.0.tgz",
+      "integrity": "sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-import-meta": {
+      "version": "7.10.4",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz",
+      "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.10.4"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-jsx": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.25.9.tgz",
+      "integrity": "sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-syntax-typescript": {
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz",
+      "integrity": "sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-typescript": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.27.0.tgz",
+      "integrity": "sha512-fRGGjO2UEGPjvEcyAZXRXAS8AfdaQoq7HnxAbJoAoW10B9xOKesmmndJv+Sym2a+9FHWZ9KbyyLCe9s0Sn5jtg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-annotate-as-pure": "^7.25.9",
+        "@babel/helper-create-class-features-plugin": "^7.27.0",
+        "@babel/helper-plugin-utils": "^7.26.5",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.25.9",
+        "@babel/plugin-syntax-typescript": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.0.tgz",
+      "integrity": "sha512-2ncevenBqXI6qRMukPlXwHKHchC7RyMuu4xv5JBXRfOGVcTy1mXCD12qrp7Jsoxll1EV3+9sE4GugBVRjT2jFA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.26.2",
+        "@babel/parser": "^7.27.0",
+        "@babel/types": "^7.27.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.27.0.tgz",
+      "integrity": "sha512-19lYZFzYVQkkHkl4Cy4WrAVcqBkgvV2YM2TU3xG6DIwO7O3ecbDPfW3yM3bjAGcqcQHi+CCtjMR3dIEHxsd6bA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.26.2",
+        "@babel/generator": "^7.27.0",
+        "@babel/parser": "^7.27.0",
+        "@babel/template": "^7.27.0",
+        "@babel/types": "^7.27.0",
+        "debug": "^4.3.1",
+        "globals": "^11.1.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.0.tgz",
+      "integrity": "sha512-H45s8fVLYjbhFH62dIJ3WtmJ6RSPt/3DRO0ZcT2SUiYiQyz3BLVb9ADEnLl91m74aQPS3AzzeajZHYOalWe3bg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.2.tgz",
+      "integrity": "sha512-wCIboOL2yXZym2cgm6mlA742s9QeJ8DjGVaL39dLN4rRwrOgOyYSnOaFPhKZGLb2ngj4EyfAFjsNJwPXZvseag==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.2.tgz",
+      "integrity": "sha512-NQhH7jFstVY5x8CKbcfa166GoV0EFkaPkCKBQkdPJFvo5u+nGXLEH/ooniLb3QI8Fk58YAx7nsPLozUWfCBOJA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.2.tgz",
+      "integrity": "sha512-5ZAX5xOmTligeBaeNEPnPaeEuah53Id2tX4c2CVP3JaROTH+j4fnfHCkr1PjXMd78hMst+TlkfKcW/DlTq0i4w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.2.tgz",
+      "integrity": "sha512-Ffcx+nnma8Sge4jzddPHCZVRvIfQ0kMsUsCMcJRHkGJ1cDmhe4SsrYIjLUKn1xpHZybmOqCWwB0zQvsjdEHtkg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.2.tgz",
+      "integrity": "sha512-MpM6LUVTXAzOvN4KbjzU/q5smzryuoNjlriAIx+06RpecwCkL9JpenNzpKd2YMzLJFOdPqBpuub6eVRP5IgiSA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.2.tgz",
+      "integrity": "sha512-5eRPrTX7wFyuWe8FqEFPG2cU0+butQQVNcT4sVipqjLYQjjh8a8+vUTfgBKM88ObB85ahsnTwF7PSIt6PG+QkA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.2.tgz",
+      "integrity": "sha512-mLwm4vXKiQ2UTSX4+ImyiPdiHjiZhIaE9QvC7sw0tZ6HoNMjYAqQpGyui5VRIi5sGd+uWq940gdCbY3VLvsO1w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.2.tgz",
+      "integrity": "sha512-6qyyn6TjayJSwGpm8J9QYYGQcRgc90nmfdUb0O7pp1s4lTY+9D0H9O02v5JqGApUyiHOtkz6+1hZNvNtEhbwRQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.2.tgz",
+      "integrity": "sha512-UHBRgJcmjJv5oeQF8EpTRZs/1knq6loLxTsjc3nxO9eXAPDLcWW55flrMVc97qFPbmZP31ta1AZVUKQzKTzb0g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.2.tgz",
+      "integrity": "sha512-gq/sjLsOyMT19I8obBISvhoYiZIAaGF8JpeXu1u8yPv8BE5HlWYobmlsfijFIZ9hIVGYkbdFhEqC0NvM4kNO0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.2.tgz",
+      "integrity": "sha512-bBYCv9obgW2cBP+2ZWfjYTU+f5cxRoGGQ5SeDbYdFCAZpYWrfjjfYwvUpP8MlKbP0nwZ5gyOU/0aUzZ5HWPuvQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.2.tgz",
+      "integrity": "sha512-SHNGiKtvnU2dBlM5D8CXRFdd+6etgZ9dXfaPCeJtz+37PIUlixvlIhI23L5khKXs3DIzAn9V8v+qb1TRKrgT5w==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.2.tgz",
+      "integrity": "sha512-hDDRlzE6rPeoj+5fsADqdUZl1OzqDYow4TB4Y/3PlKBD0ph1e6uPHzIQcv2Z65u2K0kpeByIyAjCmjn1hJgG0Q==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.2.tgz",
+      "integrity": "sha512-tsHu2RRSWzipmUi9UBDEzc0nLc4HtpZEI5Ba+Omms5456x5WaNuiG3u7xh5AO6sipnJ9r4cRWQB2tUjPyIkc6g==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.2.tgz",
+      "integrity": "sha512-k4LtpgV7NJQOml/10uPU0s4SAXGnowi5qBSjaLWMojNCUICNu7TshqHLAEbkBdAszL5TabfvQ48kK84hyFzjnw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.2.tgz",
+      "integrity": "sha512-GRa4IshOdvKY7M/rDpRR3gkiTNp34M0eLTaC1a08gNrh4u488aPhuZOCpkF6+2wl3zAN7L7XIpOFBhnaE3/Q8Q==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.2.tgz",
+      "integrity": "sha512-QInHERlqpTTZ4FRB0fROQWXcYRD64lAoiegezDunLpalZMjcUcld3YzZmVJ2H/Cp0wJRZ8Xtjtj0cEHhYc/uUg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.2.tgz",
+      "integrity": "sha512-talAIBoY5M8vHc6EeI2WW9d/CkiO9MQJ0IOWX8hrLhxGbro/vBXJvaQXefW2cP0z0nQVTdQ/eNyGFV1GSKrxfw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.2.tgz",
+      "integrity": "sha512-voZT9Z+tpOxrvfKFyfDYPc4DO4rk06qamv1a/fkuzHpiVBMOhpjK+vBmWM8J1eiB3OLSMFYNaOaBNLXGChf5tg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.2.tgz",
+      "integrity": "sha512-dcXYOC6NXOqcykeDlwId9kB6OkPUxOEqU+rkrYVqJbK2hagWOMrsTGsMr8+rW02M+d5Op5NNlgMmjzecaRf7Tg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.2.tgz",
+      "integrity": "sha512-t/TkWwahkH0Tsgoq1Ju7QfgGhArkGLkF1uYz8nQS/PPFlXbP5YgRpqQR3ARRiC2iXoLTWFxc6DJMSK10dVXluw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.2.tgz",
+      "integrity": "sha512-cfZH1co2+imVdWCjd+D1gf9NjkchVhhdpgb1q5y6Hcv9TP6Zi9ZG/beI3ig8TvwT9lH9dlxLq5MQBBgwuj4xvA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.2.tgz",
+      "integrity": "sha512-7Loyjh+D/Nx/sOTzV8vfbB3GJuHdOQyrOryFdZvPHLf42Tk9ivBU5Aedi7iyX+x6rbn2Mh68T4qq1SDqJBQO5Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.2.tgz",
+      "integrity": "sha512-WRJgsz9un0nqZJ4MfhabxaD9Ft8KioqU3JMinOTvobbX6MOSUigSBlogP8QB3uxpJDsFS6yN+3FDBdqE5lg9kg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.2.tgz",
+      "integrity": "sha512-kM3HKb16VIXZyIeVrM1ygYmZBKybX8N4p754bw390wGO3Tf2j4L2/WYL+4suWujpgf6GBYs3jv7TyUivdd05JA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.8",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
+      "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/set-array": "^1.2.1",
+        "@jridgewell/sourcemap-codec": "^1.4.10",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/set-array": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz",
+      "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
+      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.25",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz",
+      "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@polka/url": {
+      "version": "1.0.0-next.28",
+      "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.28.tgz",
+      "integrity": "sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/pluginutils": {
+      "version": "5.1.4",
+      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.4.tgz",
+      "integrity": "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "estree-walker": "^2.0.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.39.0.tgz",
+      "integrity": "sha512-lGVys55Qb00Wvh8DMAocp5kIcaNzEFTmGhfFd88LfaogYTRKrdxgtlO5H6S49v2Nd8R2C6wLOal0qv6/kCkOwA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.39.0.tgz",
+      "integrity": "sha512-It9+M1zE31KWfqh/0cJLrrsCPiF72PoJjIChLX+rEcujVRCb4NLQ5QzFkzIZW8Kn8FTbvGQBY5TkKBau3S8cCQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.39.0.tgz",
+      "integrity": "sha512-lXQnhpFDOKDXiGxsU9/l8UEGGM65comrQuZ+lDcGUx+9YQ9dKpF3rSEGepyeR5AHZ0b5RgiligsBhWZfSSQh8Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.39.0.tgz",
+      "integrity": "sha512-mKXpNZLvtEbgu6WCkNij7CGycdw9cJi2k9v0noMb++Vab12GZjFgUXD69ilAbBh034Zwn95c2PNSz9xM7KYEAQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.39.0.tgz",
+      "integrity": "sha512-jivRRlh2Lod/KvDZx2zUR+I4iBfHcu2V/BA2vasUtdtTN2Uk3jfcZczLa81ESHZHPHy4ih3T/W5rPFZ/hX7RtQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.39.0.tgz",
+      "integrity": "sha512-8RXIWvYIRK9nO+bhVz8DwLBepcptw633gv/QT4015CpJ0Ht8punmoHU/DuEd3iw9Hr8UwUV+t+VNNuZIWYeY7Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.39.0.tgz",
+      "integrity": "sha512-mz5POx5Zu58f2xAG5RaRRhp3IZDK7zXGk5sdEDj4o96HeaXhlUwmLFzNlc4hCQi5sGdR12VDgEUqVSHer0lI9g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.39.0.tgz",
+      "integrity": "sha512-+YDwhM6gUAyakl0CD+bMFpdmwIoRDzZYaTWV3SDRBGkMU/VpIBYXXEvkEcTagw/7VVkL2vA29zU4UVy1mP0/Yw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.39.0.tgz",
+      "integrity": "sha512-EKf7iF7aK36eEChvlgxGnk7pdJfzfQbNvGV/+l98iiMwU23MwvmV0Ty3pJ0p5WQfm3JRHOytSIqD9LB7Bq7xdQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.39.0.tgz",
+      "integrity": "sha512-vYanR6MtqC7Z2SNr8gzVnzUul09Wi1kZqJaek3KcIlI/wq5Xtq4ZPIZ0Mr/st/sv/NnaPwy/D4yXg5x0B3aUUA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.39.0.tgz",
+      "integrity": "sha512-NMRUT40+h0FBa5fb+cpxtZoGAggRem16ocVKIv5gDB5uLDgBIwrIsXlGqYbLwW8YyO3WVTk1FkFDjMETYlDqiw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.39.0.tgz",
+      "integrity": "sha512-0pCNnmxgduJ3YRt+D+kJ6Ai/r+TaePu9ZLENl+ZDV/CdVczXl95CbIiwwswu4L+K7uOIGf6tMo2vm8uadRaICQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.39.0.tgz",
+      "integrity": "sha512-t7j5Zhr7S4bBtksT73bO6c3Qa2AV/HqiGlj9+KB3gNF5upcVkx+HLgxTm8DK4OkzsOYqbdqbLKwvGMhylJCPhQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.39.0.tgz",
+      "integrity": "sha512-m6cwI86IvQ7M93MQ2RF5SP8tUjD39Y7rjb1qjHgYh28uAPVU8+k/xYWvxRO3/tBN2pZkSMa5RjnPuUIbrwVxeA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.39.0.tgz",
+      "integrity": "sha512-iRDJd2ebMunnk2rsSBYlsptCyuINvxUfGwOUldjv5M4tpa93K8tFMeYGpNk2+Nxl+OBJnBzy2/JCscGeO507kA==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.39.0.tgz",
+      "integrity": "sha512-t9jqYw27R6Lx0XKfEFe5vUeEJ5pF3SGIM6gTfONSMb7DuG6z6wfj2yjcoZxHg129veTqU7+wOhY6GX8wmf90dA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.39.0.tgz",
+      "integrity": "sha512-ThFdkrFDP55AIsIZDKSBWEt/JcWlCzydbZHinZ0F/r1h83qbGeenCt/G/wG2O0reuENDD2tawfAj2s8VK7Bugg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.39.0.tgz",
+      "integrity": "sha512-jDrLm6yUtbOg2TYB3sBF3acUnAwsIksEYjLeHL+TJv9jg+TmTwdyjnDex27jqEMakNKf3RwwPahDIt7QXCSqRQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.39.0.tgz",
+      "integrity": "sha512-6w9uMuza+LbLCVoNKL5FSLE7yvYkq9laSd09bwS0tMjkwXrmib/4KmoJcrKhLWHvw19mwU+33ndC69T7weNNjQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.39.0.tgz",
+      "integrity": "sha512-yAkUOkIKZlK5dl7u6dg897doBgLXmUHhIINM2c+sND3DZwnrdQkkSiDh7N75Ll4mM4dxSkYfXqU9fW3lLkMFug==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@sec-ant/readable-stream": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz",
+      "integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@sindresorhus/merge-streams": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz",
+      "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz",
+      "integrity": "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-vue": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.3.tgz",
+      "integrity": "sha512-IYSLEQj4LgZZuoVpdSUCw3dIynTWQgPlaRP6iAvMle4My0HdYwr5g5wQAfwOeHQBmYwEkqF70nRpSilr6PoUDg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^5.0.0 || ^6.0.0",
+        "vue": "^3.2.25"
+      }
+    },
+    "node_modules/@vue/babel-helper-vue-transform-on": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@vue/babel-helper-vue-transform-on/-/babel-helper-vue-transform-on-1.4.0.tgz",
+      "integrity": "sha512-mCokbouEQ/ocRce/FpKCRItGo+013tHg7tixg3DUNS+6bmIchPt66012kBMm476vyEIJPafrvOf4E5OYj3shSw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@vue/babel-plugin-jsx": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@vue/babel-plugin-jsx/-/babel-plugin-jsx-1.4.0.tgz",
+      "integrity": "sha512-9zAHmwgMWlaN6qRKdrg1uKsBKHvnUU+Py+MOCTuYZBoZsopa90Di10QRjB+YPnVss0BZbG/H5XFwJY1fTxJWhA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.25.9",
+        "@babel/helper-plugin-utils": "^7.26.5",
+        "@babel/plugin-syntax-jsx": "^7.25.9",
+        "@babel/template": "^7.26.9",
+        "@babel/traverse": "^7.26.9",
+        "@babel/types": "^7.26.9",
+        "@vue/babel-helper-vue-transform-on": "1.4.0",
+        "@vue/babel-plugin-resolve-type": "1.4.0",
+        "@vue/shared": "^3.5.13"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "@babel/core": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vue/babel-plugin-resolve-type": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/@vue/babel-plugin-resolve-type/-/babel-plugin-resolve-type-1.4.0.tgz",
+      "integrity": "sha512-4xqDRRbQQEWHQyjlYSgZsWj44KfiF6D+ktCuXyZ8EnVDYV3pztmXJDf1HveAjUAXxAnR8daCQT51RneWWxtTyQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.26.2",
+        "@babel/helper-module-imports": "^7.25.9",
+        "@babel/helper-plugin-utils": "^7.26.5",
+        "@babel/parser": "^7.26.9",
+        "@vue/compiler-sfc": "^3.5.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sxzz"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@vue/compiler-core": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.13.tgz",
+      "integrity": "sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.25.3",
+        "@vue/shared": "3.5.13",
+        "entities": "^4.5.0",
+        "estree-walker": "^2.0.2",
+        "source-map-js": "^1.2.0"
+      }
+    },
+    "node_modules/@vue/compiler-dom": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.13.tgz",
+      "integrity": "sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-core": "3.5.13",
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/compiler-sfc": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.13.tgz",
+      "integrity": "sha512-6VdaljMpD82w6c2749Zhf5T9u5uLBWKnVue6XWxprDobftnletJ8+oel7sexFfM3qIxNmVE7LSFGTpv6obNyaQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.25.3",
+        "@vue/compiler-core": "3.5.13",
+        "@vue/compiler-dom": "3.5.13",
+        "@vue/compiler-ssr": "3.5.13",
+        "@vue/shared": "3.5.13",
+        "estree-walker": "^2.0.2",
+        "magic-string": "^0.30.11",
+        "postcss": "^8.4.48",
+        "source-map-js": "^1.2.0"
+      }
+    },
+    "node_modules/@vue/compiler-ssr": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.13.tgz",
+      "integrity": "sha512-wMH6vrYHxQl/IybKJagqbquvxpWCuVYpoUJfCqFZwa/JY1GdATAQ+TgVtgrwwMZ0D07QhA99rs/EAAWfvG6KpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.13",
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/devtools-api": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-7.7.2.tgz",
+      "integrity": "sha512-1syn558KhyN+chO5SjlZIwJ8bV/bQ1nOVTG66t2RbG66ZGekyiYNmRO7X9BJCXQqPsFHlnksqvPhce2qpzxFnA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-kit": "^7.7.2"
+      }
+    },
+    "node_modules/@vue/devtools-core": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-core/-/devtools-core-7.7.2.tgz",
+      "integrity": "sha512-lexREWj1lKi91Tblr38ntSsy6CvI8ba7u+jmwh2yruib/ltLUcsIzEjCnrkh1yYGGIKXbAuYV2tOG10fGDB9OQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-kit": "^7.7.2",
+        "@vue/devtools-shared": "^7.7.2",
+        "mitt": "^3.0.1",
+        "nanoid": "^5.0.9",
+        "pathe": "^2.0.2",
+        "vite-hot-client": "^0.2.4"
+      },
+      "peerDependencies": {
+        "vue": "^3.0.0"
+      }
+    },
+    "node_modules/@vue/devtools-core/node_modules/nanoid": {
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.5.tgz",
+      "integrity": "sha512-Ir/+ZpE9fDsNH0hQ3C68uyThDXzYcim2EqcZ8zn8Chtt1iylPT9xXJB0kPCnqzgcEGikO9RxSrh63MsmVCU7Fw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.js"
+      },
+      "engines": {
+        "node": "^18 || >=20"
+      }
+    },
+    "node_modules/@vue/devtools-kit": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.2.tgz",
+      "integrity": "sha512-CY0I1JH3Z8PECbn6k3TqM1Bk9ASWxeMtTCvZr7vb+CHi+X/QwQm5F1/fPagraamKMAHVfuuCbdcnNg1A4CYVWQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-shared": "^7.7.2",
+        "birpc": "^0.2.19",
+        "hookable": "^5.5.3",
+        "mitt": "^3.0.1",
+        "perfect-debounce": "^1.0.0",
+        "speakingurl": "^14.0.1",
+        "superjson": "^2.2.1"
+      }
+    },
+    "node_modules/@vue/devtools-shared": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.2.tgz",
+      "integrity": "sha512-uBFxnp8gwW2vD6FrJB8JZLUzVb6PNRG0B0jBnHsOH8uKyva2qINY8PTF5Te4QlTbMDqU5K6qtJDr6cNsKWhbOA==",
+      "license": "MIT",
+      "dependencies": {
+        "rfdc": "^1.4.1"
+      }
+    },
+    "node_modules/@vue/reactivity": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.13.tgz",
+      "integrity": "sha512-NaCwtw8o48B9I6L1zl2p41OHo/2Z4wqYGGIK1Khu5T7yxrn+ATOixn/Udn2m+6kZKB/J7cuT9DbWWhRxqixACg==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/runtime-core": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.13.tgz",
+      "integrity": "sha512-Fj4YRQ3Az0WTZw1sFe+QDb0aXCerigEpw418pw1HBUKFtnQHWzwojaukAs2X/c9DQz4MQ4bsXTGlcpGxU/RCIw==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.13",
+        "@vue/shared": "3.5.13"
+      }
+    },
+    "node_modules/@vue/runtime-dom": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.13.tgz",
+      "integrity": "sha512-dLaj94s93NYLqjLiyFzVs9X6dWhTdAlEAciC3Moq7gzAc13VJUdCnjjRurNM6uTLFATRHexHCTu/Xp3eW6yoog==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/reactivity": "3.5.13",
+        "@vue/runtime-core": "3.5.13",
+        "@vue/shared": "3.5.13",
+        "csstype": "^3.1.3"
+      }
+    },
+    "node_modules/@vue/server-renderer": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.13.tgz",
+      "integrity": "sha512-wAi4IRJV/2SAW3htkTlB+dHeRmpTiVIK1OGLWV1yeStVSebSQQOwGwIq0D3ZIoBj2C2qpgz5+vX9iEBkTdk5YA==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-ssr": "3.5.13",
+        "@vue/shared": "3.5.13"
+      },
+      "peerDependencies": {
+        "vue": "3.5.13"
+      }
+    },
+    "node_modules/@vue/shared": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.13.tgz",
+      "integrity": "sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==",
+      "license": "MIT"
+    },
+    "node_modules/birpc": {
+      "version": "0.2.19",
+      "resolved": "https://registry.npmjs.org/birpc/-/birpc-0.2.19.tgz",
+      "integrity": "sha512-5WeXXAvTmitV1RqJFppT5QtUiz2p1mRSYU000Jkft5ZUCLJIk4uQriYNO50HknxKwM6jd8utNc66K1qGIwwWBQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.24.4",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz",
+      "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "caniuse-lite": "^1.0.30001688",
+        "electron-to-chromium": "^1.5.73",
+        "node-releases": "^2.0.19",
+        "update-browserslist-db": "^1.1.1"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/bundle-name": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz",
+      "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "run-applescript": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001712",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001712.tgz",
+      "integrity": "sha512-MBqPpGYYdQ7/hfKiet9SCI+nmN5/hp4ZzveOJubl5DTAMa5oggjAuoi0Z4onBpKPFI2ePGnQuQIzF3VxDjDJig==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/copy-anything": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-3.0.5.tgz",
+      "integrity": "sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==",
+      "license": "MIT",
+      "dependencies": {
+        "is-what": "^4.1.8"
+      },
+      "engines": {
+        "node": ">=12.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mesqueeb"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
+      "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/default-browser": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz",
+      "integrity": "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "bundle-name": "^4.1.0",
+        "default-browser-id": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/default-browser-id": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.0.tgz",
+      "integrity": "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/define-lazy-prop": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz",
+      "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.134",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.134.tgz",
+      "integrity": "sha512-zSwzrLg3jNP3bwsLqWHmS5z2nIOQ5ngMnfMZOWWtXnqqQkPVyOipxK98w+1beLw1TB+EImPNcG8wVP/cLVs2Og==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/error-stack-parser-es": {
+      "version": "0.1.5",
+      "resolved": "https://registry.npmjs.org/error-stack-parser-es/-/error-stack-parser-es-0.1.5.tgz",
+      "integrity": "sha512-xHku1X40RO+fO8yJ8Wh2f2rZWVjqyhb1zgq1yZ8aZRQkv6OOKhKWRUaht3eSCUbAOBaKIgM+ykwFLE+QUxgGeg==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.25.2",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.2.tgz",
+      "integrity": "sha512-16854zccKPnC+toMywC+uKNeYSv+/eXkevRAfwRD/G9Cleq66m8XFIrigkbvauLLlCfDL45Q2cWegSg53gGBnQ==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.25.2",
+        "@esbuild/android-arm": "0.25.2",
+        "@esbuild/android-arm64": "0.25.2",
+        "@esbuild/android-x64": "0.25.2",
+        "@esbuild/darwin-arm64": "0.25.2",
+        "@esbuild/darwin-x64": "0.25.2",
+        "@esbuild/freebsd-arm64": "0.25.2",
+        "@esbuild/freebsd-x64": "0.25.2",
+        "@esbuild/linux-arm": "0.25.2",
+        "@esbuild/linux-arm64": "0.25.2",
+        "@esbuild/linux-ia32": "0.25.2",
+        "@esbuild/linux-loong64": "0.25.2",
+        "@esbuild/linux-mips64el": "0.25.2",
+        "@esbuild/linux-ppc64": "0.25.2",
+        "@esbuild/linux-riscv64": "0.25.2",
+        "@esbuild/linux-s390x": "0.25.2",
+        "@esbuild/linux-x64": "0.25.2",
+        "@esbuild/netbsd-arm64": "0.25.2",
+        "@esbuild/netbsd-x64": "0.25.2",
+        "@esbuild/openbsd-arm64": "0.25.2",
+        "@esbuild/openbsd-x64": "0.25.2",
+        "@esbuild/sunos-x64": "0.25.2",
+        "@esbuild/win32-arm64": "0.25.2",
+        "@esbuild/win32-ia32": "0.25.2",
+        "@esbuild/win32-x64": "0.25.2"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/estree-walker": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz",
+      "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==",
+      "license": "MIT"
+    },
+    "node_modules/execa": {
+      "version": "9.5.2",
+      "resolved": "https://registry.npmjs.org/execa/-/execa-9.5.2.tgz",
+      "integrity": "sha512-EHlpxMCpHWSAh1dgS6bVeoLAXGnJNdR93aabr4QCGbzOM73o5XmRfM/e5FUqsw3aagP8S8XEWUWFAxnRBnAF0Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sindresorhus/merge-streams": "^4.0.0",
+        "cross-spawn": "^7.0.3",
+        "figures": "^6.1.0",
+        "get-stream": "^9.0.0",
+        "human-signals": "^8.0.0",
+        "is-plain-obj": "^4.1.0",
+        "is-stream": "^4.0.1",
+        "npm-run-path": "^6.0.0",
+        "pretty-ms": "^9.0.0",
+        "signal-exit": "^4.1.0",
+        "strip-final-newline": "^4.0.0",
+        "yoctocolors": "^2.0.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.5.0"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/execa?sponsor=1"
+      }
+    },
+    "node_modules/figures": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz",
+      "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-unicode-supported": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/fs-extra": {
+      "version": "11.3.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.0.tgz",
+      "integrity": "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=14.14"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/get-stream": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz",
+      "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@sec-ant/readable-stream": "^0.4.1",
+        "is-stream": "^4.0.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/globals": {
+      "version": "11.12.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+      "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/hajimiui": {
+      "resolved": "",
+      "link": true
+    },
+    "node_modules/hookable": {
+      "version": "5.5.3",
+      "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz",
+      "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==",
+      "license": "MIT"
+    },
+    "node_modules/human-signals": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.1.tgz",
+      "integrity": "sha512-eKCa6bwnJhvxj14kZk5NCPc6Hb6BdsU9DZcOnmQKSnO1VKrfV0zCvtttPZUsBvjmNDn8rpcJfpwSYnHBjc95MQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18.18.0"
+      }
+    },
+    "node_modules/is-docker": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz",
+      "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "is-docker": "cli.js"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-inside-container": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz",
+      "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-docker": "^3.0.0"
+      },
+      "bin": {
+        "is-inside-container": "cli.js"
+      },
+      "engines": {
+        "node": ">=14.16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-stream": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
+      "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-unicode-supported": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz",
+      "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/is-what": {
+      "version": "4.1.16",
+      "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.16.tgz",
+      "integrity": "sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.13"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/mesqueeb"
+      }
+    },
+    "node_modules/is-wsl": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz",
+      "integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-inside-container": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz",
+      "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/kolorist": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/kolorist/-/kolorist-1.8.0.tgz",
+      "integrity": "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/magic-string": {
+      "version": "0.30.17",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",
+      "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0"
+      }
+    },
+    "node_modules/mitt": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz",
+      "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==",
+      "license": "MIT"
+    },
+    "node_modules/mrmime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.19",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz",
+      "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/npm-run-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz",
+      "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^4.0.0",
+        "unicorn-magic": "^0.3.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/path-key": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/open": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/open/-/open-10.1.0.tgz",
+      "integrity": "sha512-mnkeQ1qP5Ue2wd+aivTD3NHd/lZ96Lu0jgf0pwktLPtx6cTZiH7tyeGRRHs0zX0rbrahXPnXlUnbeXyaBBuIaw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "default-browser": "^5.2.1",
+        "define-lazy-prop": "^3.0.0",
+        "is-inside-container": "^1.0.0",
+        "is-wsl": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parse-ms": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/parse-ms/-/parse-ms-4.0.0.tgz",
+      "integrity": "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/perfect-debounce": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
+      "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
+      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pinia": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/pinia/-/pinia-3.0.1.tgz",
+      "integrity": "sha512-WXglsDzztOTH6IfcJ99ltYZin2mY8XZCXujkYWVIJlBjqsP6ST7zw+Aarh63E1cDVYeyUcPCxPHzJpEOmzB6Wg==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-api": "^7.7.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/posva"
+      },
+      "peerDependencies": {
+        "typescript": ">=4.4.4",
+        "vue": "^2.7.0 || ^3.5.11"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.3",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz",
+      "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.8",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/pretty-ms": {
+      "version": "9.2.0",
+      "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.2.0.tgz",
+      "integrity": "sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "parse-ms": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/rfdc": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
+      "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==",
+      "license": "MIT"
+    },
+    "node_modules/rollup": {
+      "version": "4.39.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.39.0.tgz",
+      "integrity": "sha512-thI8kNc02yNvnmJp8dr3fNWJ9tCONDhp6TV35X6HkKGGs9E6q7YWCHbe5vKiTa7TAiNcFEmXKj3X/pG2b3ci0g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.7"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.39.0",
+        "@rollup/rollup-android-arm64": "4.39.0",
+        "@rollup/rollup-darwin-arm64": "4.39.0",
+        "@rollup/rollup-darwin-x64": "4.39.0",
+        "@rollup/rollup-freebsd-arm64": "4.39.0",
+        "@rollup/rollup-freebsd-x64": "4.39.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.39.0",
+        "@rollup/rollup-linux-arm-musleabihf": "4.39.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.39.0",
+        "@rollup/rollup-linux-arm64-musl": "4.39.0",
+        "@rollup/rollup-linux-loongarch64-gnu": "4.39.0",
+        "@rollup/rollup-linux-powerpc64le-gnu": "4.39.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.39.0",
+        "@rollup/rollup-linux-riscv64-musl": "4.39.0",
+        "@rollup/rollup-linux-s390x-gnu": "4.39.0",
+        "@rollup/rollup-linux-x64-gnu": "4.39.0",
+        "@rollup/rollup-linux-x64-musl": "4.39.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.39.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.39.0",
+        "@rollup/rollup-win32-x64-msvc": "4.39.0",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/run-applescript": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz",
+      "integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/sirv": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.1.tgz",
+      "integrity": "sha512-FoqMu0NCGBLCcAkS1qA+XJIQTR6/JHfQXl+uGteNCQ76T91DMUjPa9xfmeqMY3z80nLSg9yQmNjK0Px6RWsH/A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@polka/url": "^1.0.0-next.24",
+        "mrmime": "^2.0.0",
+        "totalist": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/speakingurl": {
+      "version": "14.0.1",
+      "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz",
+      "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/strip-final-newline": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz",
+      "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/superjson": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.2.tgz",
+      "integrity": "sha512-5JRxVqC8I8NuOUjzBbvVJAKNM8qoVuH0O77h4WInc/qC2q5IreqKxYwgkga3PfA22OayK2ikceb/B26dztPl+Q==",
+      "license": "MIT",
+      "dependencies": {
+        "copy-anything": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/totalist": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz",
+      "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/unicorn-magic": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz",
+      "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz",
+      "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-6.2.5.tgz",
+      "integrity": "sha512-j023J/hCAa4pRIUH6J9HemwYfjB5llR2Ps0CWeikOtdR8+pAURAk0DoJC5/mm9kd+UgdnIy7d6HE4EAvlYhPhA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.25.0",
+        "postcss": "^8.5.3",
+        "rollup": "^4.30.1"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "jiti": ">=1.21.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-hot-client": {
+      "version": "0.2.4",
+      "resolved": "https://registry.npmjs.org/vite-hot-client/-/vite-hot-client-0.2.4.tgz",
+      "integrity": "sha512-a1nzURqO7DDmnXqabFOliz908FRmIppkBKsJthS8rbe8hBEXwEwe4C3Pp33Z1JoFCYfVL4kTOMLKk0ZZxREIeA==",
+      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      },
+      "peerDependencies": {
+        "vite": "^2.6.0 || ^3.0.0 || ^4.0.0 || ^5.0.0-0 || ^6.0.0-0"
+      }
+    },
+    "node_modules/vite-plugin-inspect": {
+      "version": "0.8.9",
+      "resolved": "https://registry.npmjs.org/vite-plugin-inspect/-/vite-plugin-inspect-0.8.9.tgz",
+      "integrity": "sha512-22/8qn+LYonzibb1VeFZmISdVao5kC22jmEKm24vfFE8siEn47EpVcCLYMv6iKOYMJfjSvSJfueOwcFCkUnV3A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@antfu/utils": "^0.7.10",
+        "@rollup/pluginutils": "^5.1.3",
+        "debug": "^4.3.7",
+        "error-stack-parser-es": "^0.1.5",
+        "fs-extra": "^11.2.0",
+        "open": "^10.1.0",
+        "perfect-debounce": "^1.0.0",
+        "picocolors": "^1.1.1",
+        "sirv": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      },
+      "peerDependencies": {
+        "vite": "^3.1.0 || ^4.0.0 || ^5.0.0-0 || ^6.0.1"
+      },
+      "peerDependenciesMeta": {
+        "@nuxt/kit": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vite-plugin-vue-devtools": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/vite-plugin-vue-devtools/-/vite-plugin-vue-devtools-7.7.2.tgz",
+      "integrity": "sha512-5V0UijQWiSBj32blkyPEqIbzc6HO9c1bwnBhx+ay2dzU0FakH+qMdNUT8nF9BvDE+i6I1U8CqCuJiO20vKEdQw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-core": "^7.7.2",
+        "@vue/devtools-kit": "^7.7.2",
+        "@vue/devtools-shared": "^7.7.2",
+        "execa": "^9.5.1",
+        "sirv": "^3.0.0",
+        "vite-plugin-inspect": "0.8.9",
+        "vite-plugin-vue-inspector": "^5.3.1"
+      },
+      "engines": {
+        "node": ">=v14.21.3"
+      },
+      "peerDependencies": {
+        "vite": "^3.1.0 || ^4.0.0-0 || ^5.0.0-0 || ^6.0.0-0"
+      }
+    },
+    "node_modules/vite-plugin-vue-inspector": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/vite-plugin-vue-inspector/-/vite-plugin-vue-inspector-5.3.1.tgz",
+      "integrity": "sha512-cBk172kZKTdvGpJuzCCLg8lJ909wopwsu3Ve9FsL1XsnLBiRT9U3MePcqrgGHgCX2ZgkqZmAGR8taxw+TV6s7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.23.0",
+        "@babel/plugin-proposal-decorators": "^7.23.0",
+        "@babel/plugin-syntax-import-attributes": "^7.22.5",
+        "@babel/plugin-syntax-import-meta": "^7.10.4",
+        "@babel/plugin-transform-typescript": "^7.22.15",
+        "@vue/babel-plugin-jsx": "^1.1.5",
+        "@vue/compiler-dom": "^3.3.4",
+        "kolorist": "^1.8.0",
+        "magic-string": "^0.30.4"
+      },
+      "peerDependencies": {
+        "vite": "^3.0.0-0 || ^4.0.0-0 || ^5.0.0-0 || ^6.0.0-0"
+      }
+    },
+    "node_modules/vue": {
+      "version": "3.5.13",
+      "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.13.tgz",
+      "integrity": "sha512-wmeiSMxkZCSc+PM2w2VRsOYAZC8GdipNFRTsLSfodVqI9mbejKeXEGr8SckuLnrQPGe3oJN5c3K0vpoU9q/wCQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/compiler-dom": "3.5.13",
+        "@vue/compiler-sfc": "3.5.13",
+        "@vue/runtime-dom": "3.5.13",
+        "@vue/server-renderer": "3.5.13",
+        "@vue/shared": "3.5.13"
+      },
+      "peerDependencies": {
+        "typescript": "*"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/vue-router": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.5.0.tgz",
+      "integrity": "sha512-HDuk+PuH5monfNuY+ct49mNmkCRK4xJAV9Ts4z9UFc4rzdDnxQLyCMGGc8pKhZhHTVzfanpNwB/lwqevcBwI4w==",
+      "license": "MIT",
+      "dependencies": {
+        "@vue/devtools-api": "^6.6.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/posva"
+      },
+      "peerDependencies": {
+        "vue": "^3.2.0"
+      }
+    },
+    "node_modules/vue-router/node_modules/@vue/devtools-api": {
+      "version": "6.6.4",
+      "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.4.tgz",
+      "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==",
+      "license": "MIT"
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/yoctocolors": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.1.tgz",
+      "integrity": "sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    }
+  }
+}

hajimiUI/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "hajimiui",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "build:app": "node build.js",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "hajimiui": "file:",
+    "pinia": "^3.0.1",
+    "vue": "^3.5.13",
+    "vue-router": "^4.5.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^5.2.3",
+    "vite": "^6.2.4",
+    "vite-plugin-vue-devtools": "^7.7.2"
+  }
+}

hajimiUI/src/App.vue

@@ -0,0 +1,14 @@
+<script setup>
+import { RouterView } from 'vue-router'
+</script>
+
+<template>
+  <RouterView />
+</template>
+
+<style>
+body {
+  margin: 0;
+  padding: 0;
+}
+</style>

hajimiUI/src/assets/base.css

@@ -0,0 +1,136 @@
+/* color palette from <https://github.com/vuejs/theme> */
+:root {
+  --vt-c-white: #ffffff;
+  --vt-c-white-soft: #f8f8f8;
+  --vt-c-white-mute: #f2f2f2;
+
+  --vt-c-black: #181818;
+  --vt-c-black-soft: #222222;
+  --vt-c-black-mute: #282828;
+
+  --vt-c-indigo: #2c3e50;
+
+  --vt-c-divider-light-1: rgba(60, 60, 60, 0.29);
+  --vt-c-divider-light-2: rgba(60, 60, 60, 0.12);
+  --vt-c-divider-dark-1: rgba(84, 84, 84, 0.65);
+  --vt-c-divider-dark-2: rgba(84, 84, 84, 0.48);
+
+  --vt-c-text-light-1: var(--vt-c-indigo);
+  --vt-c-text-light-2: rgba(60, 60, 60, 0.66);
+  --vt-c-text-dark-1: var(--vt-c-white);
+  --vt-c-text-dark-2: rgba(235, 235, 235, 0.64);
+}
+
+/* semantic color variables for this project */
+:root {
+  --color-background: var(--vt-c-white);
+  --color-background-soft: var(--vt-c-white-soft);
+  --color-background-mute: var(--vt-c-white-mute);
+
+  --color-border: var(--vt-c-divider-light-2);
+  --color-border-hover: var(--vt-c-divider-light-1);
+
+  --color-heading: var(--vt-c-text-light-1);
+  --color-text: var(--vt-c-text-light-1);
+
+  --section-gap: 160px;
+  
+  /* 自定义颜色变量 */
+  --card-background: #ffffff;
+  --card-border: #e0e0e0;
+  --button-primary: #007bff;
+  --button-primary-hover: #0069d9;
+  --button-text: #ffffff;
+  --stats-item-bg: #f8f9fa;
+  --log-entry-bg: #f8f9fa;
+  --log-entry-border: #e9ecef;
+  --toggle-bg: #ccc;
+  --toggle-active: #007bff;
+}
+
+/* 夜间模式变量 */
+.dark-mode {
+  --color-background: var(--vt-c-black);
+  --color-background-soft: var(--vt-c-black-soft);
+  --color-background-mute: var(--vt-c-black-mute);
+
+  --color-border: var(--vt-c-divider-dark-2);
+  --color-border-hover: var(--vt-c-divider-dark-1);
+
+  --color-heading: var(--vt-c-text-dark-1);
+  --color-text: var(--vt-c-text-dark-2);
+  
+  /* 自定义夜间模式颜色 */
+  --card-background: #2d2d2d;
+  --card-border: #444444;
+  --button-primary: #0056b3;
+  --button-primary-hover: #004494;
+  --button-text: #ffffff;
+  --stats-item-bg: #333333;
+  --log-entry-bg: #333333;
+  --log-entry-border: #444444;
+  --toggle-bg: #555555;
+  --toggle-active: #0056b3;
+}
+
+/* 保留系统偏好设置的支持 */
+@media (prefers-color-scheme: dark) {
+  :root:not(.dark-mode):not(.light-mode) {
+    --color-background: var(--vt-c-black);
+    --color-background-soft: var(--vt-c-black-soft);
+    --color-background-mute: var(--vt-c-black-mute);
+
+    --color-border: var(--vt-c-divider-dark-2);
+    --color-border-hover: var(--vt-c-divider-dark-1);
+
+    --color-heading: var(--vt-c-text-dark-1);
+    --color-text: var(--vt-c-text-dark-2);
+    
+    /* 自定义夜间模式颜色 */
+    --card-background: #2d2d2d;
+    --card-border: #444444;
+    --button-primary: #0056b3;
+    --button-primary-hover: #004494;
+    --button-text: #ffffff;
+    --stats-item-bg: #333333;
+    --log-entry-bg: #333333;
+    --log-entry-border: #444444;
+    --toggle-bg: #555555;
+    --toggle-active: #0056b3;
+  }
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  margin: 0;
+  font-weight: normal;
+}
+
+body {
+  min-height: 100vh;
+  color: var(--color-text);
+  background: var(--color-background);
+  transition:
+    color 0.5s,
+    background-color 0.5s;
+  line-height: 1.6;
+  font-family:
+    Inter,
+    -apple-system,
+    BlinkMacSystemFont,
+    'Segoe UI',
+    Roboto,
+    Oxygen,
+    Ubuntu,
+    Cantarell,
+    'Fira Sans',
+    'Droid Sans',
+    'Helvetica Neue',
+    sans-serif;
+  font-size: 15px;
+  text-rendering: optimizeLegibility;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}