api-key-manager 5.0.1__tar.gz → 5.0.2__tar.gz

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-key-manager
-Version: 5.0.1
+Version: 5.0.2
 Summary: Batch manage API keys for 45+ AI providers with CLI and Web interfaces
 Author: Townrain
 License: MIT
@@ -62,14 +62,14 @@ Dynamic: license-file
 - **API 文档** - Swagger UI 和 Redoc 自动文档
 - **国际化** - 支持中英文错误信息
 - **SDK 支持** - Python 和 TypeScript 客户端库
-- **桌面应用** - Tauri v2.5 原生桌面应用（v5.0.0 新增），Windows / macOS / Linux
+- **桌面应用** - 单 exe 便携安装，React 前端 + pywebview 桌面窗口
 - **Webhook 通知** - 事件驱动的 Webhook 通知系统
 
 ## 快速开始
 
-### 桌面应用（v5.0.0）
+### 桌面应用（v5.0.2）
 
-从 [Releases](https://github.com/Townrain/API-Key-Manager/releases) 下载对应平台的安装包，解压后运行 `keyhub-desktop.exe`。
+从 [Releases](https://github.com/Townrain/API-Key-Manager/releases) 下载 `KeyHub-Setup.exe`，选择任意目录安装即可。首次启动自动生成配置文件，所有数据保持在安装目录内。
 
 ### CLI / Web
 

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/README.md

@@ -22,14 +22,14 @@
 - **API 文档** - Swagger UI 和 Redoc 自动文档
 - **国际化** - 支持中英文错误信息
 - **SDK 支持** - Python 和 TypeScript 客户端库
-- **桌面应用** - Tauri v2.5 原生桌面应用（v5.0.0 新增），Windows / macOS / Linux
+- **桌面应用** - 单 exe 便携安装，React 前端 + pywebview 桌面窗口
 - **Webhook 通知** - 事件驱动的 Webhook 通知系统
 
 ## 快速开始
 
-### 桌面应用（v5.0.0）
+### 桌面应用（v5.0.2）
 
-从 [Releases](https://github.com/Townrain/API-Key-Manager/releases) 下载对应平台的安装包，解压后运行 `keyhub-desktop.exe`。
+从 [Releases](https://github.com/Townrain/API-Key-Manager/releases) 下载 `KeyHub-Setup.exe`，选择任意目录安装即可。首次启动自动生成配置文件，所有数据保持在安装目录内。
 
 ### CLI / Web
 

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/api_key_manager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: api-key-manager
-Version: 5.0.1
+Version: 5.0.2
 Summary: Batch manage API keys for 45+ AI providers with CLI and Web interfaces
 Author: Townrain
 License: MIT
@@ -62,14 +62,14 @@ Dynamic: license-file
 - **API 文档** - Swagger UI 和 Redoc 自动文档
 - **国际化** - 支持中英文错误信息
 - **SDK 支持** - Python 和 TypeScript 客户端库
-- **桌面应用** - Tauri v2.5 原生桌面应用（v5.0.0 新增），Windows / macOS / Linux
+- **桌面应用** - 单 exe 便携安装，React 前端 + pywebview 桌面窗口
 - **Webhook 通知** - 事件驱动的 Webhook 通知系统
 
 ## 快速开始
 
-### 桌面应用（v5.0.0）
+### 桌面应用（v5.0.2）
 
-从 [Releases](https://github.com/Townrain/API-Key-Manager/releases) 下载对应平台的安装包，解压后运行 `keyhub-desktop.exe`。
+从 [Releases](https://github.com/Townrain/API-Key-Manager/releases) 下载 `KeyHub-Setup.exe`，选择任意目录安装即可。首次启动自动生成配置文件，所有数据保持在安装目录内。
 
 ### CLI / Web
 

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/__init__.py

@@ -13,5 +13,5 @@ __all__ = [
     "KeyStore",
 ]
 
-__version__ = "5.0.1"
+__version__ = "5.0.2"
 

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/config.py

@@ -1,5 +1,6 @@
 import copy
 import logging
+import sys
 from pathlib import Path
 
 import yaml
@@ -77,8 +78,30 @@ def _validate_config(config: dict) -> dict:
     return config
 
 
+def _copy_example_config(config_path: Path):
+    """Copy bundled config.yaml.example to config.yaml on first run."""
+    if getattr(sys, "frozen", False):
+        sample = Path(sys._MEIPASS) / "config.yaml.example"
+    else:
+        sample = Path("config.yaml.example")
+    if sample.exists():
+        try:
+            config_path.write_bytes(sample.read_bytes())
+            logger.info(f"Created default config at {config_path}")
+        except OSError:
+            pass
+
+
 def load_config(path: str = "config.yaml") -> dict:
+    # PyInstaller exe: resolve path next to the exe, auto-create from example
+    if getattr(sys, "frozen", False):
+        exe_dir = Path(sys.argv[0]).parent
+        path = str(exe_dir / "config.yaml")
+
     config_path = Path(path)
+    if not config_path.exists():
+        _copy_example_config(config_path)
+
     if config_path.exists():
         try:
             with open(config_path, encoding="utf-8") as f:

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/logger.py

@@ -4,11 +4,18 @@ from datetime import datetime
 from pathlib import Path
 
 
+def _ensure_logs_dir(logs_dir: str = "./data/logs") -> Path:
+    """Create and return the logs directory."""
+    d = Path(logs_dir)
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
 class KeyLogger:
     """Structured logger with date-based file rotation."""
 
     def __init__(self, logs_dir: str, category: str):
-        self.logs_dir = Path(logs_dir)
+        self.logs_dir = _ensure_logs_dir(logs_dir)
         self.category = category
         self.logger = logging.getLogger(f"keymanager.{category}")
         self.logger.setLevel(logging.DEBUG)
@@ -16,7 +23,6 @@ class KeyLogger:
             self._setup_file_handler()
 
     def _setup_file_handler(self):
-        self.logs_dir.mkdir(parents=True, exist_ok=True)
         date_str = datetime.now().strftime("%Y-%m-%d")
         log_file = self.logs_dir / f"{self.category}_{date_str}.log"
 
@@ -44,8 +50,7 @@ class ProjectLogger:
     """Main project logger that logs all operations."""
 
     def __init__(self, logs_dir: str = "./data/logs"):
-        self.logs_dir = Path(logs_dir)
-        self.logs_dir.mkdir(parents=True, exist_ok=True)
+        self.logs_dir = _ensure_logs_dir(logs_dir)
         self._setup_loggers()
 
     def _setup_loggers(self):
@@ -228,5 +233,12 @@ class ProjectLogger:
         return {"success": True, "date": date, "deleted_lines": lines_count}
 
 
-# Global logger instance
-project_logger = ProjectLogger()
+# Lazy singleton — defers directory creation to first get_project_logger() call
+_project_logger: "ProjectLogger | None" = None
+
+def get_project_logger() -> "ProjectLogger":
+    """Return the singleton ProjectLogger, creating it on first access."""
+    global _project_logger
+    if _project_logger is None:
+        _project_logger = ProjectLogger()
+    return _project_logger

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/storage.py

@@ -3,6 +3,7 @@ import json
 import logging
 import os
 import secrets
+import sys
 from pathlib import Path
 
 from cryptography.hazmat.primitives import hashes
@@ -14,6 +15,13 @@ from key_manager.errors import ErrorCode, StorageError
 logger = logging.getLogger(__name__)
 
 
+def _resolve_config_path() -> Path:
+    """Resolve config.yaml path — next to exe when frozen, CWD otherwise."""
+    if getattr(sys, "frozen", False):
+        return Path(sys.argv[0]).parent / "config.yaml"
+    return Path("config.yaml")
+
+
 _ITERATIONS = 600_000  # OWASP 2023 recommendation for PBKDF2-HMAC-SHA256
 _LEGACY_SALT = b"key-manager-aes256gcm-salt-v1"  # For backward compatibility
 _API_TOKEN_SALT = b"key-manager-api-auth-token-v1"  # Domain-specific salt for API token
@@ -51,6 +59,20 @@ def clear_key_cache() -> None:
     _key_cache.clear()
 
 
+def clear_passphrase_cache() -> None:
+    """Clear the module-level passphrase cache.
+
+    Call this in test teardown to prevent cross-test pollution.
+    """
+    global _passphrase_cache
+    _passphrase_cache = None
+
+
+def clear_all_caches() -> None:
+    """Clear all module-level caches (keys + passphrase)."""
+    clear_key_cache()
+    clear_passphrase_cache()
+
 def derive_api_token(config: dict | None = None, salt: bytes = None) -> str:
     """Derive an API authentication token from the encryption passphrase.
 
@@ -80,27 +102,53 @@ def derive_api_token(config: dict | None = None, salt: bytes = None) -> str:
     _key_cache[cache_key] = token_bytes
     return token_bytes.hex()
 
+_passphrase_cache: str | None = None
+
 def _get_passphrase(config: dict | None = None) -> str:
-    """Get encryption passphrase from config, env var, or auto-generate."""
+    """Get encryption passphrase from cache, env var, config, or auto-generate.
+
+    Uses a module-level cache so all callers get the same passphrase,
+    even when config dicts are loaded at different times.
+    """
+    global _passphrase_cache
+    if _passphrase_cache is not None:
+        return _passphrase_cache
+
     # 1. Check environment variable
     secret = os.environ.get("KEY_MANAGER_SECRET")
     if secret:
+        _passphrase_cache = secret
         return secret
 
-    # 2. Check config file
+    # 2. Check in-memory config dict (fast path)
     if config and config.get("encryption", {}).get("passphrase"):
-        return config["encryption"]["passphrase"]
+        _passphrase_cache = config["encryption"]["passphrase"]
+        return _passphrase_cache
 
-    # 3. Auto-generate and save
+    # 3. Read from config file on disk (catches passphrases saved by another caller)
+    try:
+        import yaml
+        config_path = _resolve_config_path()
+        if config_path.exists():
+            disk_cfg = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+            passphrase = disk_cfg.get("encryption", {}).get("passphrase")
+            if passphrase:
+                _passphrase_cache = passphrase
+                return passphrase
+    except Exception:
+        pass
+
+    # 4. Auto-generate and save
     passphrase = secrets.token_urlsafe(32)
     _save_passphrase_to_config(passphrase)
+    _passphrase_cache = passphrase
     logger.info("Auto-generated encryption passphrase and saved to config.yaml")
     return passphrase
 
 
 def _save_passphrase_to_config(passphrase: str) -> None:
     """Append encryption passphrase to config.yaml without rewriting existing content."""
-    config_path = Path("config.yaml")
+    config_path = _resolve_config_path()
 
     try:
         existing = ""
@@ -178,7 +226,7 @@ class KeyStore:
         encrypted = self.config.get("storage", {}).get("encrypted", True) is True
         if not encrypted:
             logger.warning("rotate_key called but storage.encrypted=false — passphrase not used")
-        clear_key_cache()  # Invalidate stale cached keys from old passphrase
+        clear_key_cache()
         if not self.path.exists():
             raise StorageError(code=ErrorCode.STORAGE_READ_ERROR, message=f"File not found: {self.path}")
         raw = self.path.read_text(encoding="utf-8")
@@ -190,9 +238,11 @@ class KeyStore:
             data = self._decrypt(envelope)
         else:
             data = envelope
+        clear_passphrase_cache()  # clear old cache so _encrypt uses new passphrase
         self.config.setdefault("encryption", {})["passphrase"] = new_passphrase
         os.environ["KEY_MANAGER_SECRET"] = new_passphrase
         self.save(data)
+        clear_passphrase_cache()  # clean up: don't leak passphrase to caller's env
         return data
 
     def _encrypt(self, data: dict) -> dict:

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/_app.py

@@ -14,7 +14,7 @@ from fastapi.templating import Jinja2Templates
 from key_manager.config import load_config
 from key_manager.detector import detect_provider  # noqa: F401
 from key_manager.errors import StorageError
-from key_manager.logger import project_logger
+from key_manager.logger import get_project_logger
 from key_manager.parser import (
     import_keys,  # noqa: F401
     validate_import_path,  # noqa: F401
@@ -58,7 +58,7 @@ app = FastAPI(
     description="Manage and validate API keys for 45+ AI providers. "
     "Import, check validity, test token limits and concurrency, "
     "query balances, and export working keys.",
-    version="5.0.1",
+    version="5.0.2",
     openapi_tags=[
         {"name": "Keys", "description": "Key management operations"},
         {"name": "Check", "description": "Key validity checking"},
@@ -76,7 +76,7 @@ app = FastAPI(
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["http://localhost:18001", "http://127.0.0.1:18001", "http://localhost:3000", "http://127.0.0.1:3000"],
+    allow_origins=["http://localhost:18001", "http://127.0.0.1:18001", "http://localhost:3000", "http://127.0.0.1:3000", "null"],
     allow_credentials=False,  # Must be False when allow_origins is "*" (CORS spec)
     allow_methods=["*"],
     allow_headers=["*"],
@@ -110,7 +110,7 @@ def _load_keys_data(config_override: dict | None = None) -> dict:
     except StorageError:
         raise
     except Exception as e:
-        project_logger.main_logger.warning(f"Failed to load/decrypt keys data: {e}")
+        get_project_logger().main_logger.warning(f"Failed to load/decrypt keys data: {e}")
         # Return empty data structure for unexpected errors (e.g., corrupt JSON)
         return {"keys": {}}
 
@@ -130,9 +130,20 @@ setup_error_handlers(app)
 # WEB UI
 # ---
 
+_TAURI_DIR = Path(__file__).resolve().parent.parent.parent / "static_tauri"
 _TEMPLATES_DIR = Path(__file__).resolve().parent.parent.parent / "templates"
 _TEMPLATES_DIR_ALT = Path(__file__).resolve().parent.parent / "templates"
 
+# Tauri React SPA: mount assets at /assets
+if (_TAURI_DIR / "assets").is_dir():
+    app.mount("/assets", StaticFiles(directory=str(_TAURI_DIR / "assets")), name="tauri_assets")
+
+# Legacy static files
+_STATIC_DIR = Path(__file__).resolve().parent.parent.parent / "static"
+if _STATIC_DIR.is_dir():
+    app.mount("/static", StaticFiles(directory=str(_STATIC_DIR)), name="static")
+
+# Jinja2 templates (legacy fallback)
 if _TEMPLATES_DIR.exists():
     templates = Jinja2Templates(directory=str(_TEMPLATES_DIR))
 elif _TEMPLATES_DIR_ALT.exists():
@@ -140,16 +151,10 @@ elif _TEMPLATES_DIR_ALT.exists():
 else:
     templates = None
 
-# Static files (CSS, JS extracted from inline)
-_STATIC_DIR = Path(__file__).resolve().parent.parent.parent / "static"
-if _STATIC_DIR.is_dir():
-    app.mount("/static", StaticFiles(directory=str(_STATIC_DIR)), name="static")
-
 
 @app.get("/", include_in_schema=False)
 async def web_ui(request: Request):
     """Serve the web UI with API token injected."""
-    # Derive API token for frontend injection
     api_token = ""
     try:
         from key_manager.storage import derive_api_token
@@ -157,13 +162,21 @@ async def web_ui(request: Request):
     except Exception:
         pass
 
+    # Tauri React SPA (preferred)
+    tauri_index = _TAURI_DIR / "index.html"
+    if tauri_index.exists():
+        html = tauri_index.read_text(encoding="utf-8")
+        html = html.replace("<title>tauri-compare</title>", "<title>KeyHub</title>")
+        html = html.replace("</head>", f"<script>window.__API_TOKEN__ = '{api_token}';</script></head>")
+        return HTMLResponse(html)
+
+    # Legacy Jinja2 template fallback
     if templates and (_TEMPLATES_DIR / "index.html").exists():
         return templates.TemplateResponse("index.html", {"request": request, "api_token": api_token})
     if templates and (_TEMPLATES_DIR_ALT / "index.html").exists():
         return templates.TemplateResponse("index.html", {"request": request, "api_token": api_token})
     return HTMLResponse("<html><body><h1>API Key Manager</h1><p>Web UI not found.</p></body></html>")
 
-
 # ---
 # Route modules (extracted to key_manager/web/routes/)
 # ---

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/middleware.py

@@ -94,7 +94,7 @@ async def rate_limit_middleware(request: Request, call_next):
 # Authentication
 # ---------------------------------------------------------------------------
 
-_AUTH_WHITELIST = {"/", "/docs", "/redoc", "/openapi.json", "/static/"}
+_AUTH_WHITELIST = {"/", "/docs", "/redoc", "/openapi.json", "/static/", "/assets/"}
 
 
 async def auth_middleware(request: Request, call_next):
@@ -114,19 +114,11 @@ async def auth_middleware(request: Request, call_next):
             pass
 
     if not api_key:
-        # Log warning once at startup (not on every request)
-        app = request.app
-        if not hasattr(app, '_auth_warning_logged'):
-            logger.warning(
-                "Authentication is disabled. Set KEY_MANAGER_API_KEY env var or "
-                "auth.api_key in config.yaml to secure your API."
-            )
-            app._auth_warning_logged = True
         return await call_next(request)
 
     # Check whitelist (including static files)
     path = request.url.path
-    if path in _AUTH_WHITELIST or path.startswith("/static/"):
+    if path in _AUTH_WHITELIST or path.startswith("/static/") or path.startswith("/assets/"):
         return await call_next(request)
 
     auth_header = request.headers.get("authorization", "")
@@ -139,7 +131,6 @@ async def auth_middleware(request: Request, call_next):
     )
     return JSONResponse(status_code=401, content=response.model_dump())
 
-
 # ---------------------------------------------------------------------------
 # Internationalization
 # ---------------------------------------------------------------------------
@@ -209,6 +200,20 @@ def setup_middleware(app: FastAPI, config: dict) -> None:
 
 def setup_error_handlers(app: FastAPI) -> None:
     """Register all error handlers on the given FastAPI app."""
+    import traceback
+
+    @app.exception_handler(Exception)
+    async def unhandled_exception_handler(request: Request, exc: Exception):
+        logger.error(f"Unhandled error on {request.method} {request.url.path}: {exc}")
+        logger.error(traceback.format_exc())
+        return JSONResponse(
+            status_code=500,
+            content=ErrorResponse(
+                error=ErrorCode.SYSTEM_INTERNAL_ERROR,
+                message=f"{type(exc).__name__}: {exc}",
+            ).model_dump(),
+        )
+
     app.exception_handler(RequestValidationError)(pydantic_validation_error_handler)
     app.exception_handler(KeyManagerError)(key_manager_error_handler)
     app.exception_handler(ValidationError)(validation_error_handler)

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/routes/balance.py

@@ -8,7 +8,7 @@ import key_manager.web._app as _app_mod
 from key_manager.api_models import BalanceRequest, BalanceResponse
 from key_manager.errors import ErrorCode, ValidationError
 from key_manager.i18n import t
-from key_manager.logger import project_logger
+from key_manager.logger import get_project_logger
 from key_manager.parser import mask_key
 from key_manager.proxy import get_proxy
 from key_manager.ssrf import get_allowed_domains, validate_custom_base_url
@@ -79,7 +79,7 @@ async def api_balance(body: BalanceRequest):
         else:
             error = "Provider does not support balance queries"
 
-        project_logger.log_web_action("balance", f"{mask_key(key)} {provider_name}: {balance_value}")
+        get_project_logger().log_web_action("balance", f"{mask_key(key)} {provider_name}: {balance_value}")
 
         return BalanceResponse(
             provider=provider_name,

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/routes/check.py

@@ -19,7 +19,7 @@ from key_manager.api_models import (
 from key_manager.detector import detect_by_prefix
 from key_manager.errors import ErrorCode, ValidationError
 from key_manager.i18n import t
-from key_manager.logger import project_logger
+from key_manager.logger import get_project_logger
 from key_manager.parser import mask_key
 from key_manager.providers import get_display_name
 from key_manager.providers.base import CheckResult, simplify_error
@@ -104,7 +104,7 @@ async def api_check(
         status_filter=s or None,
         progress_callback=_make_progress_callback(),
     )
-    project_logger.log_web_action("check_all", f"total={results.get('total', 0)}")
+    get_project_logger().log_web_action("check_all", f"total={results.get('total', 0)}")
 
     # Dispatch webhook
     task = asyncio.create_task(
@@ -215,7 +215,7 @@ async def api_check_single(body: CheckSingleRequest):
 
             status_str = "valid" if result.valid else ("invalid" if result.status_code in (401, 403) else "error")
 
-            project_logger.log_web_action("check_single", f"{mask_key(key)} {provider_name}: {status_str}")
+            get_project_logger().log_web_action("check_single", f"{mask_key(key)} {provider_name}: {status_str}")
 
             # Simplify error message for readability
             simplified_error = simplify_error(result.error, result.status_code) if result.error else None
@@ -242,7 +242,7 @@ async def api_check_single(body: CheckSingleRequest):
                         "created_at": timestamp,
                     }
                     _app_mod._save_keys_data(data)
-                    project_logger.log_web_action("auto_import", f"{mask_key(key)} from check")
+                    get_project_logger().log_web_action("auto_import", f"{mask_key(key)} from check")
                 else:
                     # Update existing key status
                     keys_dict[key]["status"] = status_str
@@ -253,7 +253,7 @@ async def api_check_single(body: CheckSingleRequest):
                     keys_dict[key]["checks"].append({"status": status_str, "provider": provider_name, "timestamp": timestamp})
                     _app_mod._save_keys_data(data)
             except Exception as e:
-                project_logger.main_logger.warning(f"Failed to auto-save checked key: {e}")
+                get_project_logger().main_logger.warning(f"Failed to auto-save checked key: {e}")
 
             return CheckSingleResponse(
                 key_masked=mask_key(key),
@@ -352,6 +352,6 @@ async def api_check_batch(body: CheckBatchRequest):
             summary.error += 1
 
     summary.total = len(batch_results)
-    project_logger.log_web_action("check_batch", f"total={summary.total}, valid={summary.valid}")
+    get_project_logger().log_web_action("check_batch", f"total={summary.total}, valid={summary.valid}")
 
     return CheckBatchResponse(results=results, summary=summary)

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/routes/keys.py

@@ -19,7 +19,7 @@ from key_manager.api_models import (
 )
 from key_manager.errors import ErrorCode, ErrorResponse, ValidationError
 from key_manager.i18n import t
-from key_manager.logger import project_logger
+from key_manager.logger import get_project_logger
 from key_manager.parser import mask_key
 
 router = APIRouter(tags=["Keys"])
@@ -62,7 +62,7 @@ async def api_import(body: ImportRequest):
             }
             new += 1
         _app_mod._save_keys_data(data)
-        project_logger.log_web_action("import", f"batch: {new} new, {dupes} dupes")
+        get_project_logger().log_web_action("import", f"batch: {new} new, {dupes} dupes")
         return ImportResponse(new=new, duplicates=dupes, errors=errors)
 
     allowed_dirs = _app_mod.config.get("scan", {}).get("directories", ["./data/input"])
@@ -80,7 +80,7 @@ async def api_import(body: ImportRequest):
         batch=None,
         keys_file=_app_mod.config["storage"]["keys_file"],
     )
-    project_logger.log_web_action("import", f"{body.file or body.directory}: {new} new, {dupes} dupes")
+    get_project_logger().log_web_action("import", f"{body.file or body.directory}: {new} new, {dupes} dupes")
     return ImportResponse(new=new, duplicates=dupes, errors=errors)
 
 
@@ -143,7 +143,7 @@ async def api_import_upload(request: Request):
     except Exception:
         pass
 
-    project_logger.log_web_action("import_upload", f"{filename}: {new} new, {dupes} dupes")
+    get_project_logger().log_web_action("import_upload", f"{filename}: {new} new, {dupes} dupes")
     return ImportResponse(new=new, duplicates=dupes, errors=errors)
 
 
@@ -225,7 +225,7 @@ async def api_export_keys(
             max_concurrency=tests.get("max_concurrency"),
         ))
 
-    project_logger.log_web_action("export", f"{len(exported)} keys")
+    get_project_logger().log_web_action("export", f"{len(exported)} keys")
     return KeyExportResponse(keys=exported, total=len(exported))
 
 
@@ -240,7 +240,7 @@ async def api_clear_keys():
         cleared = len(data.get("keys", {}))
         data["keys"] = {}
         _app_mod._save_keys_data(data)
-    project_logger.log_web_action("clear", f"{cleared} keys removed")
+    get_project_logger().log_web_action("clear", f"{cleared} keys removed")
     return {"cleared": cleared}
 
 
@@ -268,7 +268,7 @@ async def api_get_full_key(request: Request):
     # Find the full key by matching key_masked
     for full_key, info in keys_dict.items():
         if info.get("key_masked") == key_masked:
-            project_logger.log_web_action("get_full_key", key_masked)
+            get_project_logger().log_web_action("get_full_key", key_masked)
             return {"key": full_key}
 
     raise ValidationError(
@@ -308,7 +308,7 @@ async def api_delete_key(request: Request):
     if key_to_delete:
         del keys_dict[key_to_delete]
         _app_mod._save_keys_data(data)
-        project_logger.log_web_action("delete", key_masked)
+        get_project_logger().log_web_action("delete", key_masked)
         return {"deleted": 1, "key_masked": key_masked}
 
     raise ValidationError(

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/routes/misc.py

@@ -15,7 +15,7 @@ from key_manager.api_models import (
     ProxyResponse,
 )
 from key_manager.errors import ErrorCode, ValidationError
-from key_manager.logger import project_logger
+from key_manager.logger import get_project_logger
 from key_manager.proxy import get_proxy
 from key_manager.web.progress import _progress_tracker, _sse_progress_event_generator
 from key_manager.webhook import webhook_manager
@@ -53,14 +53,14 @@ async def api_proxy():
 @router.get("/api/logs", tags=["Logs"], response_model=LogsResponse)
 async def api_logs():
     """Get recent log entries."""
-    logs = project_logger.get_recent_logs()
+    logs = get_project_logger().get_recent_logs()
     return LogsResponse(logs=logs)  # Return strings directly for frontend compatibility
 
 
 @router.get("/api/logs/operations", tags=["Logs"], response_model=OperationsResponse)
 async def api_logs_operations():
     """Get recent operation log entries."""
-    operations = project_logger.get_operations_log()
+    operations = get_project_logger().get_operations_log()
     return OperationsResponse(operations=[OperationEntry(**entry) for entry in operations])
 
 
@@ -74,7 +74,7 @@ async def api_logs_clear(date: str = None):
     Returns:
         dict with success status and details
     """
-    result = project_logger.clear_main_log(date)
+    result = get_project_logger().clear_main_log(date)
     return result
 
 

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/key_manager/web/routes/test.py

@@ -10,7 +10,7 @@ import key_manager.web._app as _app_mod
 from key_manager.api_models import TestSingleRequest, TestSingleResponse
 from key_manager.errors import ErrorCode, ValidationError
 from key_manager.i18n import t
-from key_manager.logger import project_logger
+from key_manager.logger import get_project_logger
 from key_manager.parser import mask_key
 from key_manager.proxy import get_proxy
 from key_manager.tester import run_test
@@ -40,7 +40,7 @@ async def api_test():
                 progress_callback=_make_progress_callback(),
             )
             _progress_tracker.done("done", results)
-            project_logger.log_web_action("test_all", f"tested={results.get('total_tested', 0)}")
+            get_project_logger().log_web_action("test_all", f"tested={results.get('total_tested', 0)}")
             await webhook_manager.dispatch(
                 WebhookEvent.BATCH_TEST_COMPLETED,
                 {"total_tested": results.get("total_tested", 0)},
@@ -128,7 +128,7 @@ async def api_test_single(body: TestSingleRequest):
         except Exception:
             pass
 
-    project_logger.log_web_action(
+    get_project_logger().log_web_action(
         "test_single",
         f"{mask_key(key)} {provider_name}: tokens={max_tokens}, concurrency={max_concurrency}",
     )

{api_key_manager-5.0.1 → api_key_manager-5.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "api-key-manager"
-version = "5.0.1"
+version = "5.0.2"
 description = "Batch manage API keys for 45+ AI providers with CLI and Web interfaces"
 readme = "README.md"
 license = {text = "MIT"}