kotonebot 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

kotonebot/devtools/web/server/rest_api.py

@@ -0,0 +1,217 @@
+import os
+import logging
+from pathlib import Path
+from typing import Any, TypeVar, Generic, Optional
+
+import cv2
+from fastapi import APIRouter, HTTPException, Query, Body
+from fastapi.responses import FileResponse, JSONResponse
+from pydantic import BaseModel
+from pydantic.generics import GenericModel
+
+from kotonebot.devtools.project.project import Project
+from kotonebot.devtools.project.scanner import scan_prefabs
+
+
+T = TypeVar("T")
+
+
+class ResponseModel(GenericModel, Generic[T]):
+    success: bool
+    message: Optional[str] = None
+    data: Optional[T] = None
+
+
+class WriteTextRequest(BaseModel):
+    content: str
+
+def create_rest_router(project: Project) -> APIRouter:
+    router = APIRouter(prefix="/api")
+    _prefabs_cache = None
+
+    project_root = Path(project.conf_path).parent.resolve()
+    thumbnail_cache_root = project_root / ".kotonebot" / "cache" / "thumbnails"
+    image_suffixes = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
+
+    def _is_image_file(path: Path) -> bool:
+        return path.suffix.lower() in image_suffixes
+
+    def _get_thumbnail_path(source: Path, size: int) -> Path:
+        if size <= 0:
+            raise ValueError("size must be positive")
+        try:
+            rel = source.resolve().relative_to(project_root)
+        except Exception as e:
+            raise ValueError(str(e))
+        size_dir = thumbnail_cache_root / str(size)
+        target_dir = size_dir / rel.parent
+        target_dir.mkdir(parents=True, exist_ok=True)
+        return target_dir / rel.name
+
+    def _ensure_thumbnail(source: Path, size: int) -> Path:
+        cache_path = _get_thumbnail_path(source, size)
+        regenerate = True
+        if cache_path.exists():
+            src_stat = source.stat()
+            cache_stat = cache_path.stat()
+            if cache_stat.st_mtime >= src_stat.st_mtime and cache_stat.st_size > 0:
+                regenerate = False
+        if regenerate:
+            img = cv2.imread(str(source))
+            if img is None:
+                raise ValueError(f"Could not read image: {source}")
+            height, width = img.shape[:2]
+            longest = max(width, height)
+            if longest <= 0:
+                raise ValueError("invalid image size")
+            scale = size / float(longest)
+            new_width = max(1, int(round(width * scale)))
+            new_height = max(1, int(round(height * scale)))
+            resized = cv2.resize(img, (new_width, new_height), interpolation=cv2.INTER_AREA)
+            cv2.imwrite(str(cache_path), resized)
+        return cache_path
+
+    def _get_safe_path(path_str: str) -> Path:
+        p = Path(path_str)
+        if not p.is_absolute():
+            p = project_root / p
+
+        try:
+            p = p.resolve()
+            if not str(p).startswith(str(project_root)):
+                raise ValueError(f"Access denied: Path {p} is outside project root {project_root}")
+        except Exception as e:
+            raise ValueError(f"Invalid path: {e}")
+
+        return p
+
+    def _ok(data: Any = None, message: Optional[str] = None) -> JSONResponse:
+        return JSONResponse(ResponseModel[Any](success=True, message=message, data=data).dict())
+
+
+    def _err(message: str) -> JSONResponse:
+        return JSONResponse(ResponseModel[Any](success=False, message=message, data=None).dict())
+
+
+    @router.get("/project/root")
+    async def get_project_root():
+        try:
+            data: dict = {"resource_root": str(project_root)}
+            # include editor configuration if available (prefabs_module, resource_path)
+            try:
+                if project.conf and project.conf.editor:
+                    data["editor"] = project.conf.editor.model_dump()
+            except Exception:
+                logging.exception("Failed to include editor config in /project/root response")
+
+            return _ok(data)
+        except Exception as e:
+            logging.exception("Error while handling /project/root")
+            return _err(str(e))
+
+    @router.get("/fs/list_dir")
+    async def list_dir(path: str = Query(..., description="Path relative to project root or absolute path")):
+        try:
+            safe_path = _get_safe_path(path)
+            if not safe_path.exists():
+                return _err("Path not found")
+            if not safe_path.is_dir():
+                return _err("Not a directory")
+
+            items = []
+            entries = sorted(list(safe_path.iterdir()), key=lambda x: (not x.is_dir(), x.name.lower()))
+            for item in entries:
+                is_image = _is_image_file(item) if item.is_file() else False
+                thumbnail_url: Optional[str]
+                if is_image:
+                    thumbnail_url = f"/api/image/thumbnail?path={item}&size=128"
+                else:
+                    thumbnail_url = None
+                items.append({
+                    "name": item.name,
+                    "isDirectory": item.is_dir(),
+                    "path": str(item),
+                    "isImage": is_image,
+                    "thumbnailUrl": thumbnail_url,
+                })
+
+            return _ok({"items": items})
+        except PermissionError:
+            return _err("Permission denied")
+        except Exception as e:
+            return _err(str(e))
+
+    @router.get("/fs/read_text")
+    async def read_text(path: str = Query(...)):
+        try:
+            safe_path = _get_safe_path(path)
+            if not safe_path.exists():
+                return _err("File not found")
+            if not safe_path.is_file():
+                return _err("Not a file")
+
+            content = safe_path.read_text(encoding="utf-8")
+            return _ok({"content": content})
+        except Exception as e:
+            return _err(str(e))
+
+    @router.put("/fs/write_text")
+    async def write_text(path: str = Query(...), body: WriteTextRequest = Body(...)):
+        try:
+            safe_path = _get_safe_path(path)
+            if not safe_path.parent.exists():
+                return _err("Parent directory does not exist")
+
+            temp_path = safe_path.with_suffix(safe_path.suffix + ".tmp")
+            temp_path.write_text(body.content, encoding="utf-8")
+            os.replace(temp_path, safe_path)
+            return _ok({"status": "ok"})
+        except Exception as e:
+            return _err(str(e))
+
+    @router.get("/image")
+    async def get_image(path: str = Query(...)):
+        safe_path = _get_safe_path(path)
+        if not safe_path.exists():
+             raise HTTPException(status_code=404, detail="Image not found")
+        
+        if not _is_image_file(safe_path):
+             raise HTTPException(status_code=400, detail="Not an image file")
+             
+        return FileResponse(safe_path)
+
+    @router.get("/image/thumbnail")
+    async def get_image_thumbnail(path: str = Query(...), size: int = Query(128, ge=1, le=2048)):
+        safe_path = _get_safe_path(path)
+        if not safe_path.exists():
+            raise HTTPException(status_code=404, detail="Image not found")
+        if not _is_image_file(safe_path):
+            raise HTTPException(status_code=400, detail="Not an image file")
+        try:
+            cache_path = _ensure_thumbnail(safe_path, size)
+        except ValueError as e:
+            raise HTTPException(status_code=400, detail=str(e))
+        return FileResponse(cache_path)
+
+    @router.get("/prefabs/schema")
+    async def get_prefabs_schema():
+        nonlocal _prefabs_cache
+        try:
+            if _prefabs_cache is not None:
+                return _ok(_prefabs_cache)
+
+            if not project.conf or not project.conf.editor or not project.conf.editor.prefabs_module:
+                return _ok({"version": 1, "prefabs": {}})
+
+            schema = scan_prefabs(project.conf.editor.prefabs_module)
+            _prefabs_cache = schema
+            return _ok(schema)
+        except Exception as e:
+            return _err(str(e))
+
+
+    @router.get("/health")
+    async def health_check():
+        return _ok({"status": "ok", "service": "kotonebot-devtools"})
+
+    return router

kotonebot/devtools/web/server/server.py

@@ -0,0 +1,85 @@
+import webbrowser
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import JSONResponse, HTMLResponse
+import uvicorn
+
+from kotonebot.devtools.project.project import Project
+from .rest_api import create_rest_router
+
+
+def create_app():
+    """Create and configure the FastAPI application."""
+    app = FastAPI(title="KotoneBot DevTools")
+
+    project = Project()
+
+    # REST API for DevTools2 (file IO, images, prefab schema)
+    app.include_router(create_rest_router(project))
+    
+    # Get the dist directory path
+    dist_dir = Path(__file__).parent.parent / "web" / "dist"
+
+    # Mount static files if dist directory exists
+    if dist_dir.exists():
+        # 优先将打包好的静态资源挂载到 /assets（如果构建将资源放在 dist/assets）
+        assets_dir = dist_dir / "assets"
+        app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+        # SPA: 直接将除 /api/* 之外的所有路径映射到 index.html
+        @app.get("/{_path:path}")
+        async def spa_catchall(_path: str):
+            # 保留 API 路由的行为
+            if _path.startswith("api/"):
+                return JSONResponse({"detail": "Not Found"}, status_code=404)
+
+            index_file = dist_dir / "index.html"
+            if index_file.exists():
+                return HTMLResponse(index_file.read_text(encoding="utf-8"))
+
+            return JSONResponse({"detail": "Not Found"}, status_code=404)
+    else:
+        # If dist doesn't exist, provide a helpful message
+        @app.get("/")
+        async def missing_dist():
+            return JSONResponse({
+                "error": "DevTools frontend not found",
+                "message": f"Expected frontend dist at {dist_dir}",
+                "info": "Build the frontend using: npm run build in kotonebot-devtool directory"
+            }, status_code=503)
+    
+    return app
+
+
+def start_devtools(
+    host: str = "127.0.0.1",
+    port: int = 1178,
+    open_browser: bool = False
+) -> None:
+    """Start the DevTools web server.
+    
+    Args:
+        host: Host to listen on (default: 127.0.0.1)
+        port: Port to listen on (default: 1178)
+        open_browser: Automatically open browser (default: False)
+    """
+    app = create_app()
+    
+    # Open browser before starting server
+    if open_browser:
+        url = f"http://{host}:{port}"
+        webbrowser.open(url)
+    
+    # Start server
+    uvicorn.run(
+        app,
+        host=host,
+        port=port,
+        log_level="info"
+    )
+
+
+if __name__ == "__main__":
+    start_devtools()

kotonebot/errors.py

@@ -1,77 +1,77 @@
-from typing import Callable
-
-
-class KotonebotError(Exception):
-    pass
-
-class KotonebotWarning(Warning):
-    pass
-
-class MissingDependencyError(KotonebotError, ImportError):
-    def __init__(self, e: ImportError, group_name: str) -> None:
-        self.original_error = e
-        super().__init__(f'Cannot import module "{e.name}". Did you forget to run "pip install kotonebot[{group_name}]"?')
-
-class UserFriendlyError(KotonebotError):
-    def __init__(
-        self,
-        message: str,
-        actions: list[tuple[int, str, Callable[[], None]]] = [],
-        *args, **kwargs
-    ) -> None:
-        super().__init__(*args, **kwargs)
-        self.message = message
-        self.actions = actions or []
-
-    @property
-    def action_buttons(self) -> list[tuple[int, str]]:
-        """
-        以 (id: int, btn_text: str) 的形式返回所有按钮定义。
-        """
-        return [(id, text) for id, text, _ in self.actions]
-    
-    def invoke(self, action_id: int):
-        """
-        执行指定 ID 的 action。
-        """
-        for id, _, func in self.actions:
-            if id == action_id:
-                func()
-                break
-        else:
-            raise ValueError(f'Action with id {action_id} not found.')
-
-class UnrecoverableError(KotonebotError):
-    pass
-
-class GameUpdateNeededError(UnrecoverableError):
-    def __init__(self):
-        super().__init__(
-            'Game update required. '
-            'Please go to Play Store and update the game manually.'
-        )
-
-class ResourceFileMissingError(KotonebotError):
-    def __init__(self, file_path: str, description: str):
-        self.file_path = file_path
-        self.description = description
-        super().__init__(f'Resource file ({description}) "{file_path}" is missing.')
-
-class TaskNotFoundError(KotonebotError):
-    def __init__(self, task_id: str):
-        self.task_id = task_id
-        super().__init__(f'Task "{task_id}" not found.')
-
-class UnscalableResolutionError(KotonebotError):
-    def __init__(self, target_resolution: tuple[int, int], screen_size: tuple[int, int]):
-        self.target_resolution = target_resolution
-        self.screen_size = screen_size
-        super().__init__(f'Cannot scale to target resolution {target_resolution}. '
-                         f'Screen size: {screen_size}')
-
-class ContextNotInitializedError(KotonebotError):
-    def __init__(self, msg: str = 'Context not initialized'):
-        super().__init__(msg)
-
-class StopCurrentTask(KotonebotError):
+from typing import Callable, Sequence
+
+
+class KotonebotError(Exception):
+    pass
+
+class KotonebotWarning(Warning):
+    pass
+
+class MissingDependencyError(KotonebotError, ImportError):
+    def __init__(self, e: ImportError, group_name: str) -> None:
+        self.original_error = e
+        super().__init__(f'Cannot import module "{e.name}". Did you forget to run "pip install kotonebot[{group_name}]"?')
+
+class UserFriendlyError(KotonebotError):
+    def __init__(
+        self,
+        message: str,
+        actions: list[tuple[int, str, Callable[[], None]]] = [],
+        *args, **kwargs
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.message = message
+        self.actions = actions or []
+
+    @property
+    def action_buttons(self) -> list[tuple[int, str]]:
+        """
+        以 (id: int, btn_text: str) 的形式返回所有按钮定义。
+        """
+        return [(id, text) for id, text, _ in self.actions]
+    
+    def invoke(self, action_id: int):
+        """
+        执行指定 ID 的 action。
+        """
+        for id, _, func in self.actions:
+            if id == action_id:
+                func()
+                break
+        else:
+            raise ValueError(f'Action with id {action_id} not found.')
+
+class UnrecoverableError(KotonebotError):
+    pass
+
+class GameUpdateNeededError(UnrecoverableError):
+    def __init__(self):
+        super().__init__(
+            'Game update required. '
+            'Please go to Play Store and update the game manually.'
+        )
+
+class ResourceFileMissingError(KotonebotError):
+    def __init__(self, file_path: str, description: str):
+        self.file_path = file_path
+        self.description = description
+        super().__init__(f'Resource file ({description}) "{file_path}" is missing.')
+
+class TaskNotFoundError(KotonebotError):
+    def __init__(self, task_id: str):
+        self.task_id = task_id
+        super().__init__(f'Task "{task_id}" not found.')
+
+class UnscalableResolutionError(KotonebotError):
+    def __init__(self, target_resolution: Sequence[int], screen_size: Sequence[int]):
+        self.target_resolution = target_resolution
+        self.screen_size = screen_size
+        super().__init__(f'Cannot scale to target resolution {target_resolution}. '
+                         f'Screen size: {screen_size}')
+
+class ContextNotInitializedError(KotonebotError):
+    def __init__(self, msg: str = 'Context not initialized'):
+        super().__init__(msg)
+
+class StopCurrentTask(KotonebotError):
     pass

kotonebot/interop/win/__init__.py

@@ -1,10 +1,14 @@
-# ruff: noqa: E402
-from kotonebot.util import require_windows
-require_windows('kotonebot.interop.win module')
-
-
-from . import _mouse as mouse
-
-__all__ = [
-    'mouse',
+# ruff: noqa: E402
+from kotonebot.util import require_windows
+require_windows('kotonebot.interop.win module')
+
+
+from . import _mouse as mouse
+from .shake_mouse import ShakeMouse
+from .window import Win32Window, FindWindowMethod
+
+__all__ = [
+    'mouse',
+    'ShakeMouse',
+    'Win32Window', 'FindWindowMethod'
 ]