@ripla/godd-mcp 0.1.2-beta-20260312091403

package/notes-api/app/models/session.py

@@ -0,0 +1,32 @@
+"""NotesEditingSession model."""
+
+from __future__ import annotations
+
+import uuid
+
+from sqlalchemy import ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import JSONB, UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base, TimestampMixin, UUIDMixin
+
+
+class NotesEditingSession(Base, UUIDMixin, TimestampMixin):
+    """Editing session (user + business date branch)."""
+
+    __tablename__ = "notes_editing_sessions"
+
+    user_id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True),
+        ForeignKey("notes_users.id", ondelete="CASCADE"),
+        nullable=False,
+    )
+    branch_name: Mapped[str] = mapped_column(String(300), nullable=False)
+    pr_number: Mapped[int | None] = mapped_column(Integer, nullable=True)
+    pr_url: Mapped[str | None] = mapped_column(String(500), nullable=True)
+    commit_count: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    business_date: Mapped[str] = mapped_column(String(10), nullable=False)
+    status: Mapped[str] = mapped_column(String(20), nullable=False, default="active")
+    changed_files: Mapped[list] = mapped_column(JSONB, nullable=False, default=list)
+
+    user: Mapped["NotesUser"] = relationship("NotesUser", back_populates="sessions")

package/notes-api/app/models/setting.py

@@ -0,0 +1,16 @@
+"""NotesSetting model."""
+
+from sqlalchemy import String
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column
+
+from app.models.base import Base
+
+
+class NotesSetting(Base):
+    """Key-value settings (KVS)."""
+
+    __tablename__ = "notes_settings"
+
+    key: Mapped[str] = mapped_column(String(100), primary_key=True)
+    value: Mapped[dict] = mapped_column(JSONB, nullable=False)

package/notes-api/app/models/user.py

@@ -0,0 +1,38 @@
+"""NotesUser model."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from sqlalchemy import DateTime, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.models.base import Base, TimestampMixin, UUIDMixin
+
+
+class NotesUser(Base, UUIDMixin, TimestampMixin):
+    """User for ripla Notes (admin/editor/viewer)."""
+
+    __tablename__ = "notes_users"
+
+    username: Mapped[str] = mapped_column(String(100), unique=True, nullable=False)
+    display_name: Mapped[str] = mapped_column(String(200), nullable=False)
+    password_hash: Mapped[str] = mapped_column(String(255), nullable=False)
+    role: Mapped[str] = mapped_column(String(20), nullable=False, default="viewer")
+    refresh_token: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    failed_login_attempts: Mapped[int] = mapped_column(Integer, nullable=False, default=0)
+    locked_until: Mapped[datetime | None] = mapped_column(
+        DateTime(timezone=True),
+        nullable=True,
+    )
+
+    sessions: Mapped[list["NotesEditingSession"]] = relationship(
+        "NotesEditingSession",
+        back_populates="user",
+        cascade="all, delete-orphan",
+    )
+    audit_logs: Mapped[list["NotesAuditLog"]] = relationship(
+        "NotesAuditLog",
+        back_populates="user",
+        foreign_keys="NotesAuditLog.user_id",
+    )

package/notes-api/app/routers/__init__.py

@@ -0,0 +1 @@
+"""API routers."""

package/notes-api/app/routers/auth.py

@@ -0,0 +1,205 @@
+"""Auth router: login, refresh, logout, me, change-password."""
+
+from datetime import datetime, timezone
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException, Request, Response
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database import get_db
+from app.models import NotesSetting, NotesUser
+from app.schemas.auth import ChangePasswordRequest, LoginRequest, TokenResponse, UserInfo
+from app.security import auth_dependency, create_access_token, hash_password, verify_password
+from app.services.audit import audit_log
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+async def _get_setting(db: AsyncSession, key: str, fallback: int | str) -> int | str:
+    """Get setting value by key."""
+    result = await db.execute(select(NotesSetting).where(NotesSetting.key == key))
+    row = result.scalar_one_or_none()
+    if row is None:
+        return fallback
+    return row.value
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(
+    request: Request,
+    body: LoginRequest,
+    db: AsyncSession = Depends(get_db),
+):
+    """Login with username/password. Returns JWT + sets refresh cookie."""
+    ip = request.client.host if request.client else None
+    if request.headers.get("x-forwarded-for"):
+        ip = request.headers.get("x-forwarded-for").split(",")[0].strip()
+
+    if not body.username or not body.password:
+        raise HTTPException(status_code=400, detail="username and password are required")
+
+    result = await db.execute(select(NotesUser).where(NotesUser.username == body.username))
+    user = result.scalar_one_or_none()
+    if user is None:
+        await audit_log(db, None, "login_failed", ip, {"username": body.username, "reason": "user_not_found"})
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    if user.locked_until and user.locked_until > datetime.now(timezone.utc):
+        remaining = int((user.locked_until - datetime.now(timezone.utc)).total_seconds() / 60)
+        await audit_log(db, user.id, "login_failed", ip, {"reason": "account_locked"})
+        raise HTTPException(status_code=423, detail=f"Account locked. Try again in {remaining} minutes.")
+
+    if not verify_password(body.password, user.password_hash):
+        max_attempts = await _get_setting(db, "max_login_attempts", 5)
+        lockout_min = await _get_setting(db, "lockout_duration_min", 15)
+        user.failed_login_attempts = (user.failed_login_attempts or 0) + 1
+        if user.failed_login_attempts >= max_attempts:
+            from datetime import timedelta
+
+            user.locked_until = datetime.now(timezone.utc) + timedelta(minutes=lockout_min)
+        await db.flush()
+        await audit_log(db, user.id, "login_failed", ip, {"reason": "wrong_password", "attempts": user.failed_login_attempts})
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    import uuid
+
+    access_token = create_access_token(
+        str(user.id),
+        user.username,
+        user.display_name,
+        user.role,
+    )
+    refresh_token = str(uuid.uuid4())
+    user.refresh_token = refresh_token
+    user.failed_login_attempts = 0
+    user.locked_until = None
+    await db.flush()
+
+    await audit_log(db, user.id, "login", ip)
+
+    expires_at = datetime.fromtimestamp(
+        datetime.now(timezone.utc).timestamp() + settings.jwt_access_expires_min * 60,
+        tz=timezone.utc,
+    ).isoformat()
+    data = TokenResponse(
+        access_token=access_token,
+        user=UserInfo(id=str(user.id), username=user.username, display_name=user.display_name, role=user.role),
+        expires_at=expires_at,
+    )
+    from fastapi.responses import JSONResponse
+
+    response = JSONResponse(content=data.model_dump(by_alias=True))
+    response.set_cookie(
+        key="refresh_token",
+        value=refresh_token,
+        httponly=True,
+        samesite="strict",
+        path="/api/auth",
+        max_age=settings.jwt_refresh_expires_days * 86400,
+    )
+    return response
+
+
+@router.post("/refresh", response_model=TokenResponse)
+async def refresh(
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+):
+    """Refresh access token using refresh_token cookie."""
+    cookie = request.headers.get("cookie", "")
+    refresh_token = None
+    for part in cookie.split(";"):
+        part = part.strip()
+        if part.startswith("refresh_token="):
+            refresh_token = part.split("=", 1)[1].strip()
+            break
+    if not refresh_token:
+        raise HTTPException(status_code=401, detail="Refresh token required")
+
+    result = await db.execute(select(NotesUser).where(NotesUser.refresh_token == refresh_token))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=401, detail="Invalid refresh token")
+
+    access_token = create_access_token(str(user.id), user.username, user.display_name, user.role)
+    expires_at = datetime.fromtimestamp(
+        datetime.now(timezone.utc).timestamp() + settings.jwt_access_expires_min * 60,
+        tz=timezone.utc,
+    ).isoformat()
+    data = TokenResponse(
+        access_token=access_token,
+        user=UserInfo(id=str(user.id), username=user.username, display_name=user.display_name, role=user.role),
+        expires_at=expires_at,
+    )
+    from fastapi.responses import JSONResponse
+
+    return JSONResponse(content=data.model_dump(by_alias=True))
+
+
+@router.post("/logout")
+async def logout(request: Request, db: AsyncSession = Depends(get_db)):
+    """Logout: clear refresh token and cookie."""
+    cookie = request.headers.get("cookie", "")
+    for part in cookie.split(";"):
+        part = part.strip()
+        if part.startswith("refresh_token="):
+            token = part.split("=", 1)[1].strip()
+            result = await db.execute(select(NotesUser).where(NotesUser.refresh_token == token))
+            user = result.scalar_one_or_none()
+            if user:
+                user.refresh_token = None
+                await db.flush()
+            break
+
+    from fastapi.responses import JSONResponse
+
+    response = JSONResponse(content={"success": True})
+    response.delete_cookie(key="refresh_token", path="/api/auth")
+    return response
+
+
+@router.get("/me")
+async def me(
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get current user info."""
+    result = await db.execute(select(NotesUser).where(NotesUser.id == UUID(payload["sub"])))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    return {
+        "id": str(user.id),
+        "username": user.username,
+        "displayName": user.display_name,
+        "role": user.role,
+        "createdAt": user.created_at.isoformat() if user.created_at else None,
+    }
+
+
+@router.post("/change-password")
+async def change_password(
+    request: Request,
+    body: ChangePasswordRequest,
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+):
+    """Change password for current user."""
+    if not body.current_password or not body.new_password:
+        raise HTTPException(status_code=400, detail="currentPassword and newPassword are required")
+
+    result = await db.execute(select(NotesUser).where(NotesUser.id == UUID(payload["sub"])))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    if not verify_password(body.current_password, user.password_hash):
+        raise HTTPException(status_code=401, detail="Current password is incorrect")
+
+    user.password_hash = hash_password(body.new_password)
+    await db.flush()
+
+    ip = request.client.host if request.client else None
+    await audit_log(db, user.id, "password_changed", ip)
+    return {"success": True}

package/notes-api/app/routers/files.py

@@ -0,0 +1,76 @@
+"""Files router: get/put file content, history."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database import get_db
+from app.security import auth_dependency, require_role
+from app.services.github import fetch_file_commits, fetch_file_content, get_github_config, get_mock_file_content
+from app.services.pr_chain import save_to_working_branch
+
+router = APIRouter(prefix="/api", tags=["files"])
+
+
+class FileUpdateBody(BaseModel):
+    """File update request body."""
+
+    content: str
+    sha: str | None = None
+    message: str | None = None
+
+
+@router.get("/files/{file_path:path}")
+async def get_file(file_path: str):
+    """Get file content. Mock mode when GITHUB_TOKEN not set."""
+    if not file_path:
+        raise HTTPException(status_code=400, detail="File path is required")
+    decoded = file_path  # Already decoded by FastAPI
+    try:
+        if settings.is_mock_mode():
+            return get_mock_file_content(decoded)
+        config = get_github_config()
+        return await fetch_file_content(decoded, config)
+    except Exception as e:
+        msg = str(e)
+        if "404" in msg:
+            raise HTTPException(status_code=404, detail="File not found")
+        raise HTTPException(status_code=500, detail=msg)
+
+
+@router.get("/history/{file_path:path}")
+async def get_history(file_path: str):
+    """Get file commit history."""
+    if not file_path:
+        raise HTTPException(status_code=400, detail="File path is required")
+    if settings.is_mock_mode():
+        return []
+    try:
+        config = get_github_config()
+        return await fetch_file_commits(file_path, config)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/files/{file_path:path}")
+async def put_file(
+    file_path: str,
+    body: FileUpdateBody,
+    db: AsyncSession = Depends(get_db),
+    payload: dict = Depends(auth_dependency),
+    _: dict = Depends(require_role("admin", "editor")),
+):
+    """Save file (PR chain). Mock mode disabled."""
+    if settings.is_mock_mode():
+        raise HTTPException(status_code=400, detail="Mock mode: save disabled")
+    try:
+        config = get_github_config()
+        user_info = {"id": str(payload["sub"]), "username": payload["username"], "displayName": payload.get("displayName", payload["username"])}
+        message = body.message or f"docs: update {file_path.split('/')[-1]}"
+        result = await save_to_working_branch(
+            db, file_path, body.content, message, body.sha, user_info, config
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

package/notes-api/app/routers/pr.py

@@ -0,0 +1,92 @@
+"""PR router: sessions, create, discard."""
+
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database import get_db
+from app.security import auth_dependency, require_role
+from app.services.github import get_github_config
+from app.services.github_pr import find_open_auto_prs
+from app.services.pr_chain import create_ready_pr, discard_changes, get_all_active_sessions, get_session_for_user
+
+router = APIRouter(prefix="/api/pr", tags=["pr"], dependencies=[Depends(auth_dependency)])
+
+
+@router.get("/sessions")
+async def list_sessions(db: AsyncSession = Depends(get_db)):
+    """Get all active sessions."""
+    if settings.is_mock_mode():
+        return {"sessions": [], "mock": True}
+    sessions = await get_all_active_sessions(db)
+    return {"sessions": sessions}
+
+
+@router.get("/my-session")
+async def my_session(
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+):
+    """Get current user's session."""
+    if settings.is_mock_mode():
+        return {"session": None, "mock": True}
+    session = await get_session_for_user(db, UUID(payload["sub"]))
+    return {"session": session}
+
+
+@router.get("/latest")
+async def latest_pr(
+    payload: dict = Depends(auth_dependency),
+):
+    """Get latest open auto PR."""
+    if settings.is_mock_mode():
+        return {"pr": None, "mock": True}
+    try:
+        config = get_github_config()
+        prs = await find_open_auto_prs(config)
+        if not prs:
+            return {"pr": None}
+        prs.sort(key=lambda p: p.get("created_at", ""), reverse=True)
+        return {"pr": prs[0]}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/create")
+async def create_pr_route(
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+    _: dict = Depends(require_role("admin", "editor")),
+):
+    """Create PR from current user's branch."""
+    if settings.is_mock_mode():
+        raise HTTPException(status_code=400, detail="Mock mode: PR creation disabled")
+    try:
+        config = get_github_config()
+        pr = await create_ready_pr(db, UUID(payload["sub"]), config)
+        return {"pr": pr}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/discard")
+async def discard_pr(
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+    _: dict = Depends(require_role("admin", "editor")),
+):
+    """Discard changes."""
+    if settings.is_mock_mode():
+        raise HTTPException(status_code=400, detail="Mock mode: discard disabled")
+    try:
+        config = get_github_config()
+        await discard_changes(db, UUID(payload["sub"]), config)
+        return {"success": True}
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

package/notes-api/app/routers/settings.py

@@ -0,0 +1,44 @@
+"""Settings router."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.dialects.postgresql import insert
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models import NotesSetting
+from app.security import auth_dependency, require_role
+
+router = APIRouter(prefix="/api/settings", tags=["settings"], dependencies=[Depends(auth_dependency)])
+
+
+@router.get("")
+async def get_settings(db: AsyncSession = Depends(get_db)):
+    """Get all settings as key-value object."""
+    result = await db.execute(select(NotesSetting))
+    rows = result.all()
+    return {row.key: row.value for row in rows}
+
+
+class SettingUpdate(BaseModel):
+    """Setting update body."""
+
+    value: int | str | list | dict
+
+
+@router.put("/{key}")
+async def update_setting(
+    key: str,
+    body: SettingUpdate,
+    db: AsyncSession = Depends(get_db),
+    _: dict = Depends(require_role("admin")),
+):
+    """Update setting (admin only)."""
+    stmt = insert(NotesSetting).values(key=key, value=body.value).on_conflict_do_update(
+        index_elements=["key"],
+        set_={"value": body.value},
+    )
+    await db.execute(stmt)
+    await db.flush()
+    return {"key": key, "value": body.value}

package/notes-api/app/routers/tree.py

@@ -0,0 +1,22 @@
+"""Tree router: file tree from GitHub."""
+
+from fastapi import APIRouter, HTTPException
+
+from app.config import settings
+from app.services.github import fetch_directory_tree, get_github_config, get_mock_tree
+
+router = APIRouter(prefix="/api", tags=["tree"])
+
+
+@router.get("/tree")
+async def get_tree(path: str | None = None):
+    """Get file tree. Mock mode when GITHUB_TOKEN not set."""
+    try:
+        if settings.is_mock_mode():
+            return get_mock_tree()
+        config = get_github_config()
+        query_path = path or config["docs_path"]
+        tree = await fetch_directory_tree(query_path, config)
+        return tree
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

package/notes-api/app/routers/users.py

@@ -0,0 +1,145 @@
+"""Users router (admin only)."""
+
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models import NotesAuditLog, NotesUser
+from app.schemas.user import UserCreate, UserUpdate
+from app.security import auth_dependency, hash_password, require_role
+from app.services.audit import audit_log
+
+router = APIRouter(prefix="/api/users", tags=["users"], dependencies=[Depends(auth_dependency), Depends(require_role("admin"))])
+
+
+@router.get("")
+async def list_users(db: AsyncSession = Depends(get_db)):
+    """List all users (admin only)."""
+    result = await db.execute(
+        select(
+            NotesUser.id,
+            NotesUser.username,
+            NotesUser.display_name,
+            NotesUser.role,
+            NotesUser.failed_login_attempts,
+            NotesUser.locked_until,
+            NotesUser.created_at,
+            NotesUser.updated_at,
+        ).order_by(NotesUser.created_at)
+    )
+    rows = result.all()
+    return [
+        {
+            "id": str(r.id),
+            "username": r.username,
+            "displayName": r.display_name,
+            "role": r.role,
+            "failedLoginAttempts": r.failed_login_attempts,
+            "lockedUntil": r.locked_until.isoformat() if r.locked_until else None,
+            "createdAt": r.created_at.isoformat() if r.created_at else None,
+            "updatedAt": r.updated_at.isoformat() if r.updated_at else None,
+        }
+        for r in rows
+    ]
+
+
+@router.post("", status_code=201)
+async def create_user(
+    body: UserCreate,
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+):
+    """Create user (admin only)."""
+    if body.role not in ("admin", "editor", "viewer"):
+        raise HTTPException(status_code=400, detail="role must be admin, editor, or viewer")
+    if len(body.password) < 8:
+        raise HTTPException(status_code=400, detail="Password must be at least 8 characters")
+
+    result = await db.execute(select(NotesUser).where(NotesUser.username == body.username))
+    if result.scalar_one_or_none():
+        raise HTTPException(status_code=409, detail="Username already exists")
+
+    user = NotesUser(
+        username=body.username,
+        display_name=body.display_name,
+        password_hash=hash_password(body.password),
+        role=body.role,
+    )
+    db.add(user)
+    await db.flush()
+    await db.refresh(user)
+
+    await audit_log(db, UUID(payload["sub"]), "user_create", detail={"targetUser": body.username, "role": body.role})
+
+    return {
+        "id": str(user.id),
+        "username": user.username,
+        "displayName": user.display_name,
+        "role": user.role,
+        "createdAt": user.created_at.isoformat() if user.created_at else None,
+    }
+
+
+@router.put("/{user_id}")
+async def update_user(
+    user_id: str,
+    body: UserUpdate,
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+):
+    """Update user (admin only)."""
+    result = await db.execute(select(NotesUser).where(NotesUser.id == UUID(user_id)))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    if body.display_name is not None:
+        user.display_name = body.display_name
+    if body.role is not None:
+        if body.role not in ("admin", "editor", "viewer"):
+            raise HTTPException(status_code=400, detail="role must be admin, editor, or viewer")
+        user.role = body.role
+    if body.password is not None:
+        if len(body.password) < 8:
+            raise HTTPException(status_code=400, detail="Password must be at least 8 characters")
+        user.password_hash = hash_password(body.password)
+
+    await db.flush()
+    await db.refresh(user)
+
+    await audit_log(db, UUID(payload["sub"]), "user_update", detail={"targetUserId": user_id, "fields": list(body.model_dump(exclude_none=True).keys())})
+
+    return {
+        "id": str(user.id),
+        "username": user.username,
+        "displayName": user.display_name,
+        "role": user.role,
+        "createdAt": user.created_at.isoformat() if user.created_at else None,
+        "updatedAt": user.updated_at.isoformat() if user.updated_at else None,
+    }
+
+
+@router.delete("/{user_id}")
+async def delete_user(
+    user_id: str,
+    payload: dict = Depends(auth_dependency),
+    db: AsyncSession = Depends(get_db),
+):
+    """Delete user (admin only)."""
+    if user_id == str(payload["sub"]):
+        raise HTTPException(status_code=400, detail="Cannot delete your own account")
+
+    result = await db.execute(select(NotesUser).where(NotesUser.id == UUID(user_id)))
+    user = result.scalar_one_or_none()
+    if user is None:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    username = user.username
+    await db.delete(user)
+    await db.flush()
+
+    await audit_log(db, UUID(payload["sub"]), "user_delete", detail={"targetUser": username})
+    return {"success": True}

package/notes-api/app/schemas/__init__.py

@@ -0,0 +1 @@
+"""Pydantic schemas."""