auto-playwright-web 0.1.0__tar.gz

auto_playwright_web-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: auto-playwright-web
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: aiosqlite>=0.20.0
+Requires-Dist: apscheduler>=3.10.4
+Requires-Dist: fastapi>=0.115.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: playwright>=1.45.0
+Requires-Dist: pytest>=8.2.0
+Requires-Dist: pytest-asyncio>=0.24.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: uvicorn>=0.30.0
+
+# Auto Playwright Web
+
+多用户 Playwright 脚本管理平台，后端使用 FastAPI，前端使用 Vite + Vue 3 + Element Plus + Monaco Editor。
+
+## 默认账号
+
+- 管理员：`admin / admin123`
+- 测试内存仓储还包含普通用户：`demo / demo123`
+
+生产 MySQL 首次初始化请先创建业务库，再执行：
+
+```bash
+mysql -uroot -p123456 auto_playwright_web < app/scripts/init_db.sql
+```
+
+## 本地开发
+
+```bash
+uv sync
+uv run uvicorn app.main:app --reload
+cd frontend
+npm install
+npm run dev
+```
+
+默认 API 前缀为 `/api`，前端开发服务器会代理到 `http://127.0.0.1:8000`。
+
+## AI 生成脚本
+
+管理员可以在脚本编辑抽屉里点击“AI 生成”，根据需求自动生成完整脚本草稿，包括脚本编码、名称、参数定义、超时时间和 Python Playwright 源码。后端不使用 OpenAI SDK，而是通过 HTTP 调用 Chat Completions 接口，并以流式响应填充前端编辑器。启用前需要配置：
+
+```bash
+OPENAI_API_KEY=你的 OpenAI API Key
+OPENAI_MODEL=gpt-5.4-mini
+OPENAI_BASE_URL=https://api.openai.com/v1
+```
+
+`OPENAI_MODEL` 和 `OPENAI_BASE_URL` 都可以按部署环境覆盖。
+
+## 脚本约定
+
+脚本由管理员维护，所有用户共享。脚本入口必须为：
+
+```python
+async def main(params: dict) -> dict:
+    print("print 输出会进入 stdout_text")
+    return {"ok": True}
+```
+
+建议脚本使用 `logging` 输出排查日志，平台同时兼容 `print`。`print` 会进入 stdout，`logging` 默认进入 stderr。

auto_playwright_web-0.1.0/README.md

@@ -0,0 +1,50 @@
+# Auto Playwright Web
+
+多用户 Playwright 脚本管理平台，后端使用 FastAPI，前端使用 Vite + Vue 3 + Element Plus + Monaco Editor。
+
+## 默认账号
+
+- 管理员：`admin / admin123`
+- 测试内存仓储还包含普通用户：`demo / demo123`
+
+生产 MySQL 首次初始化请先创建业务库，再执行：
+
+```bash
+mysql -uroot -p123456 auto_playwright_web < app/scripts/init_db.sql
+```
+
+## 本地开发
+
+```bash
+uv sync
+uv run uvicorn app.main:app --reload
+cd frontend
+npm install
+npm run dev
+```
+
+默认 API 前缀为 `/api`，前端开发服务器会代理到 `http://127.0.0.1:8000`。
+
+## AI 生成脚本
+
+管理员可以在脚本编辑抽屉里点击“AI 生成”，根据需求自动生成完整脚本草稿，包括脚本编码、名称、参数定义、超时时间和 Python Playwright 源码。后端不使用 OpenAI SDK，而是通过 HTTP 调用 Chat Completions 接口，并以流式响应填充前端编辑器。启用前需要配置：
+
+```bash
+OPENAI_API_KEY=你的 OpenAI API Key
+OPENAI_MODEL=gpt-5.4-mini
+OPENAI_BASE_URL=https://api.openai.com/v1
+```
+
+`OPENAI_MODEL` 和 `OPENAI_BASE_URL` 都可以按部署环境覆盖。
+
+## 脚本约定
+
+脚本由管理员维护，所有用户共享。脚本入口必须为：
+
+```python
+async def main(params: dict) -> dict:
+    print("print 输出会进入 stdout_text")
+    return {"ok": True}
+```
+
+建议脚本使用 `logging` 输出排查日志，平台同时兼容 `print`。`print` 会进入 stdout，`logging` 默认进入 stderr。

auto_playwright_web-0.1.0/app/__init__.py

@@ -0,0 +1 @@
+"""Playwright 脚本管理平台后端包。"""

auto_playwright_web-0.1.0/app/cli.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+
+def init_workspace(target_dir: Path | str = ".") -> None:
+    """初始化标准工作区目录与示例脚本。"""
+    ws = Path(target_dir).resolve()
+    scripts_dir = ws / "scripts"
+    common_dir = ws / "common"
+    storage_dir = ws / ".storage"
+
+    scripts_dir.mkdir(parents=True, exist_ok=True)
+    common_dir.mkdir(parents=True, exist_ok=True)
+    storage_dir.mkdir(parents=True, exist_ok=True)
+
+    # 写入 common/__init__.py
+    init_py = common_dir / "__init__.py"
+    if not init_py.exists():
+        init_py.write_text("# 公共工具包\n", encoding="utf-8")
+
+    # 写入 .env.example
+    env_example = ws / ".env.example"
+    if not env_example.exists():
+        env_example.write_text(
+            "# 工作区环境变量模板\n# APW_API_KEY=your_secret_key\n# BILIBILI_USERNAME=demo\n# BILIBILI_PASSWORD=secret\n",
+            encoding="utf-8",
+        )
+
+    # 写入示例脚本 scripts/example.py
+    example_script = scripts_dir / "example.py"
+    if not example_script.exists():
+        example_script.write_text(
+            '''"""
+---
+name: 示例演示任务
+timeout: 30
+params:
+  keyword:
+    type: string
+    default: "Playwright"
+    description: 搜索关键字
+---
+"""
+async def main(params: dict) -> dict:
+    keyword = params.get("keyword", "")
+    print(f"[example] 正在执行任务，关键字: {keyword}")
+    return {"ok": True, "keyword": keyword}
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main({"keyword": "LocalTest"}))
+''',
+            encoding="utf-8",
+        )
+    print(f"✅ 工作区初始化完成: {ws}")
+
+
+def start_server(host: str, port: int, workdir: str) -> None:
+    """启动 Web 界面与 API 守护进程。"""
+    ws = Path(workdir).resolve()
+    os.environ["SCRIPTS_DIR"] = str(ws / "scripts")
+    os.environ["DB_PATH"] = str(ws / "data.db")
+    os.environ["RUNNER_WORKSPACE"] = str(ws / ".runner")
+
+    import uvicorn
+    from app.main import create_app
+
+    app = create_app(
+        db_path=ws / "data.db",
+        scripts_dir=ws / "scripts",
+        runner_workspace=ws / ".runner",
+    )
+    print(f"🚀 auto-playwright-web 启动中: http://{host}:{port}")
+    uvicorn.run(app, host=host, port=port)
+
+
+def run_script_cli(script_code: str, params_str: str, workdir: str) -> None:
+    """在终端直接触发指定脚本执行。"""
+    ws = Path(workdir).resolve()
+    from app.repositories.sqlite import SQLiteRepository
+    from app.service.execution_service import ExecutionService
+    from app.service.script_loader import ScriptLoader
+
+    repo = SQLiteRepository(ws / "data.db")
+    loader = ScriptLoader(ws / "scripts")
+    service = ExecutionService(
+        repository=repo,
+        script_loader=loader,
+        runner_workspace=ws / ".runner",
+        workspace_dir=ws,
+    )
+
+    try:
+        params = json.loads(params_str) if params_str else {}
+    except Exception as e:
+        print(f"❌ 参数解析失败，请提供合法的 JSON 字符串: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    async def _execute():
+        await repo.init_db()
+        execution = await service.execute_sync(script_code, params, source="cli")
+        print("---------- 执行结果 ----------")
+        print(f"状态: {execution.status}")
+        print(f"耗时: {execution.duration_ms}ms")
+        if execution.stdout_text:
+            print(f"输出:\n{execution.stdout_text}")
+        if execution.result_json:
+            print(f"返回值:\n{json.dumps(execution.result_json, ensure_ascii=False, indent=2)}")
+        if execution.error_stack:
+            print(f"异常堆栈:\n{execution.error_stack}", file=sys.stderr)
+
+    asyncio.run(_execute())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="apw", description="Auto-Playwright-Web 命令行工具")
+    subparsers = parser.add_subparsers(dest="subcommand", help="子命令")
+
+    # start
+    p_start = subparsers.add_parser("start", help="启动 Web 界面与 API 服务")
+    p_start.add_argument("--host", default="0.0.0.0", help="监听地址 (默认 0.0.0.0)")
+    p_start.add_argument("--port", type=int, default=8000, help="端口 (默认 8000)")
+    p_start.add_argument("--workdir", default=".", help="工作区目录 (默认当前目录)")
+
+    # init
+    p_init = subparsers.add_parser("init", help="初始化标准工作区")
+    p_init.add_argument("--workdir", default=".", help="工作区目录 (默认当前目录)")
+
+    # run
+    p_run = subparsers.add_parser("run", help="命令行直接执行脚本")
+    p_run.add_argument("script_code", help="脚本编码")
+    p_run.add_argument("--params", default="{}", help="入参 JSON 字符串")
+    p_run.add_argument("--workdir", default=".", help="工作区目录 (默认当前目录)")
+
+    # version
+    subparsers.add_parser("version", help="查看当前版本")
+
+    args = parser.parse_args()
+
+    if args.subcommand == "start":
+        start_server(args.host, args.port, args.workdir)
+    elif args.subcommand == "init":
+        init_workspace(args.workdir)
+    elif args.subcommand == "run":
+        run_script_cli(args.script_code, args.params, args.workdir)
+    elif args.subcommand == "version":
+        print(f"auto-playwright-web v{__version__}")
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

auto_playwright_web-0.1.0/app/configs/__init__.py

@@ -0,0 +1 @@
+"""配置模块：按运行环境组织应用配置。"""

auto_playwright_web-0.1.0/app/configs/base.py

@@ -0,0 +1,19 @@
+import os
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Settings:
+    """应用配置。"""
+
+    app_name: str = os.getenv("APP_NAME", "auto-playwright-web")
+    app_env: str = os.getenv("APP_ENV", "prod")
+    enable_docs: bool = os.getenv("APP_ENABLE_DOCS", "true").lower() == "true"
+    api_key: str = os.getenv("APW_API_KEY", "")
+    runner_workspace: str = os.getenv("RUNNER_WORKSPACE", ".runner")
+    scripts_dir: str = os.getenv("SCRIPTS_DIR", "scripts")
+    db_path: str = os.getenv("DB_PATH", "data.db")
+    max_concurrent_executions: int = int(os.getenv("MAX_CONCURRENT_EXECUTIONS", "3"))
+
+
+settings = Settings()

auto_playwright_web-0.1.0/app/configs/config.py

@@ -0,0 +1,3 @@
+from app.configs.base import Settings, settings
+
+__all__ = ["Settings", "settings"]

auto_playwright_web-0.1.0/app/dependencies.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from fastapi import Depends, Header, HTTPException, Request, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from app.domain import User
+from app.repositories.base import Repository
+from app.security import decode_access_token
+from app.service.auth_service import AuthService
+from app.service.ai_service import AIScriptService
+from app.service.common_library_service import CommonLibraryService
+from app.service.execution_service import ExecutionService
+from app.service.schedule_service import ScheduleService
+from app.service.script_service import ScriptService
+from app.service.token_service import TokenService
+from app.service.user_env_var_service import UserEnvVarService
+from app.service.webhook_service import WebhookService
+
+bearer_scheme = HTTPBearer(auto_error=False)
+
+
+def get_repository(request: Request) -> Repository:
+    """从应用状态获取仓储。"""
+
+    return request.app.state.repository
+
+
+def get_auth_service(request: Request) -> AuthService:
+    """从应用状态获取认证服务。"""
+
+    return request.app.state.auth_service
+
+
+def get_ai_script_service(request: Request) -> AIScriptService:
+    """从应用状态获取 AI 脚本生成服务。"""
+
+    return request.app.state.ai_script_service
+
+
+def get_script_service(request: Request) -> ScriptService:
+    """从应用状态获取脚本服务。"""
+
+    return request.app.state.script_service
+
+
+def get_common_library_service(request: Request) -> CommonLibraryService:
+    """从应用状态获取公共函数库服务。"""
+
+    return request.app.state.common_library_service
+
+
+def get_execution_service(request: Request) -> ExecutionService:
+    """从应用状态获取执行服务。"""
+
+    return request.app.state.execution_service
+
+
+def get_token_service(request: Request) -> TokenService:
+    """从应用状态获取 Token 服务。"""
+
+    return request.app.state.token_service
+
+
+def get_schedule_service(request: Request) -> ScheduleService:
+    """从应用状态获取定时任务服务。"""
+
+    return request.app.state.schedule_service
+
+
+def get_webhook_service(request: Request) -> WebhookService:
+    """从应用状态获取 Webhook 服务。"""
+
+    return request.app.state.webhook_service
+
+
+def get_user_env_var_service(request: Request) -> UserEnvVarService:
+    """从应用状态获取用户环境变量服务。"""
+
+    return request.app.state.user_env_var_service
+
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
+    auth_service: AuthService = Depends(get_auth_service),
+) -> User:
+    """解析 Bearer JWT 并返回当前用户。"""
+
+    if not credentials:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="请先登录")
+    payload = decode_access_token(credentials.credentials)
+    return await auth_service.get_user(int(payload["sub"]))
+
+
+async def get_open_api_token(x_api_token: str | None = Header(default=None)) -> str:
+    """读取开放 API Token 请求头。"""
+
+    if not x_api_token:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="缺少 X-API-Token")
+    return x_api_token
+
+
+async def get_current_user_or_token(
+    request: Request,
+    credentials: HTTPAuthorizationCredentials | None = Depends(bearer_scheme),
+    x_api_token: str | None = Header(default=None),
+    auth_service: AuthService = Depends(get_auth_service),
+    token_service: TokenService = Depends(get_token_service),
+) -> User:
+    """统一认证：优先 Bearer JWT，其次 X-API-Token，并校验接口授权范围。"""
+
+    if credentials:
+        payload = decode_access_token(credentials.credentials)
+        return await auth_service.get_user(int(payload["sub"]))
+
+    if x_api_token:
+        user, scopes = await token_service.authenticate_token_scopes(x_api_token)
+        if scopes:
+            route_key = f"{request.method}:{request.scope['route'].path}"
+            if route_key not in scopes:
+                raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="API Token 无权访问此接口")
+        return user
+
+    raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="请先登录或提供 API Token")

auto_playwright_web-0.1.0/app/domain.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+def now() -> datetime:
+    """返回当前时间。"""
+    return datetime.now()
+
+
+@dataclass(slots=True)
+class Execution:
+    """脚本执行记录。"""
+
+    id: int
+    execution_id: str
+    script_id: int
+    script_code: str
+    user_id: int = 1
+    source: str = "manual"
+    params_json: dict[str, Any] = field(default_factory=dict)
+    status: str = "pending"
+    result_json: dict[str, Any] | None = None
+    stdout_text: str = ""
+    stderr_text: str = ""
+    error_stack: str = ""
+    duration_ms: int = 0
+    started_time: datetime | None = None
+    finished_time: datetime | None = None
+    create_time: datetime = field(default_factory=now)
+    update_time: datetime = field(default_factory=now)
+    create_by: str = ""
+    update_by: str = ""
+
+
+@dataclass(slots=True)
+class Schedule:
+    """定时任务。"""
+
+    id: int
+    user_id: int
+    script_id: int
+    script_code: str
+    name: str
+    cron_expr: str
+    params_json: dict[str, Any]
+    enabled: bool = True
+    last_run_time: datetime | None = None
+    next_run_time: datetime | None = None
+    create_time: datetime = field(default_factory=now)
+    update_time: datetime = field(default_factory=now)
+    create_by: str = ""
+    update_by: str = ""
+
+
+@dataclass(slots=True)
+class User:
+    """单用户身份兼容。"""
+
+    id: int = 1
+    username: str = "admin"
+    role: str = "admin"
+    enabled: bool = True

auto_playwright_web-0.1.0/app/main.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Request, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from app.configs.config import settings
+from app.repositories.sqlite import SQLiteRepository
+from app.routers import executions, open_api, schedules, scripts, user_env_vars
+from app.scheduler import PlatformScheduler
+from app.service.execution_service import ExecutionService
+from app.service.script_loader import ScriptLoader
+
+
+def create_app(
+    db_path: Path | str | None = None,
+    scripts_dir: Path | str | None = None,
+    runner_workspace: Path | str | None = None,
+    start_scheduler: bool = True,
+) -> FastAPI:
+    """创建并装配轻量级 FastAPI 应用。"""
+
+    # 加载本地 .env
+    load_dotenv()
+
+    resolved_db_path = Path(db_path or settings.db_path)
+    resolved_scripts_dir = Path(scripts_dir or settings.scripts_dir)
+    resolved_workspace = Path(runner_workspace or settings.runner_workspace)
+
+    repository = SQLiteRepository(resolved_db_path)
+    script_loader = ScriptLoader(resolved_scripts_dir)
+    execution_service = ExecutionService(
+        repository=repository,
+        script_loader=script_loader,
+        runner_workspace=resolved_workspace,
+        max_concurrent_executions=settings.max_concurrent_executions,
+    )
+    platform_scheduler = PlatformScheduler(repository, execution_service)
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        await repository.init_db()
+        if start_scheduler:
+            await platform_scheduler.start()
+        try:
+            yield
+        finally:
+            await platform_scheduler.stop()
+
+    app = FastAPI(
+        title=settings.app_name,
+        docs_url="/docs" if settings.enable_docs else None,
+        redoc_url="/redoc" if settings.enable_docs else None,
+        openapi_url="/openapi.json" if settings.enable_docs else None,
+        lifespan=lifespan,
+    )
+
+    # 全局 API Key 拦截（如果配置了 APW_API_KEY）
+    @app.middleware("http")
+    async def api_key_auth_middleware(request: Request, call_next):
+        api_key = settings.api_key or os.getenv("APW_API_KEY", "")
+        if api_key and request.url.path.startswith("/api/"):
+            client_key = request.headers.get("X-API-Key") or request.query_params.get("api_key")
+            if client_key != api_key:
+                return JSONResponse(status_code=401, content={"detail": "无效的 API Key"})
+        return await call_next(request)
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.state.repository = repository
+    app.state.script_loader = script_loader
+    app.state.execution_service = execution_service
+    app.state.platform_scheduler = platform_scheduler
+
+    app.include_router(scripts.router)
+    app.include_router(open_api.router)
+    app.include_router(executions.router)
+    app.include_router(schedules.router)
+    app.include_router(user_env_vars.router)
+
+    # 挂载内置静态前端（若存在）
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.mount("/assets", StaticFiles(directory=static_dir / "assets"), name="assets")
+
+        @app.get("/{full_path:path}", include_in_schema=False)
+        async def serve_spa(full_path: str):
+            if full_path.startswith("api/") or full_path.startswith("docs") or full_path.startswith("openapi"):
+                raise HTTPException(status_code=404, detail="Not Found")
+            target = static_dir / full_path
+            if target.is_file():
+                return FileResponse(target)
+            return FileResponse(static_dir / "index.html")
+
+    return app
+
+
+app = create_app()

auto_playwright_web-0.1.0/app/repositories/__init__.py

@@ -0,0 +1 @@
+"""仓储模块：隔离业务逻辑与持久化实现。"""

auto_playwright_web-0.1.0/app/repositories/base.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Protocol
+
+from app.domain import Execution, Schedule
+
+
+class Repository(Protocol):
+    """仓储接口协议：SQLiteRepository 实现此协议。"""
+
+    async def init_db(self) -> None: ...
+
+    async def create_execution(self, execution: Execution) -> Execution: ...
+
+    async def update_execution(self, execution: Execution) -> Execution: ...
+
+    async def get_execution(self, execution_id: str | int) -> Execution | None: ...
+
+    async def list_executions(
+        self,
+        script_code: str | None = None,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        limit: int = 100,
+    ) -> list[Execution]: ...
+
+    async def create_schedule(self, schedule: Schedule) -> Schedule: ...
+
+    async def update_schedule(self, schedule_id: int, schedule: Schedule) -> Schedule: ...
+
+    async def delete_schedule(self, schedule_id: int) -> None: ...
+
+    async def get_schedule(self, schedule_id: int) -> Schedule | None: ...
+
+    async def list_schedules(self) -> list[Schedule]: ...
+
+    async def list_enabled_schedules(self) -> list[Schedule]: ...