skrift 0.1.0a2__py3-none-any.whl → 0.1.0a4__py3-none-any.whl

skrift/alembic/env.py

@@ -12,6 +12,7 @@ from skrift.config import get_settings
 from skrift.db.base import Base
 
 # Import all models to ensure they're registered with Base.metadata
+from skrift.db.models.oauth_account import OAuthAccount  # noqa: F401
 from skrift.db.models.user import User  # noqa: F401
 from skrift.db.models.page import Page  # noqa: F401
 from skrift.db.models.role import Role, RolePermission  # noqa: F401
@@ -31,7 +32,7 @@ def get_url() -> str:
     """Get database URL from settings or alembic.ini."""
     try:
         settings = get_settings()
-        return settings.database_url
+        return settings.db.url
     except Exception:
         # Fall back to alembic.ini config if settings can't be loaded
         return config.get_main_option("sqlalchemy.url", "")

skrift/alembic/versions/20260129_add_oauth_accounts.py

@@ -0,0 +1,134 @@
+"""add oauth_accounts table
+
+Revision ID: 1a2b3c4d5e6f
+Revises: 8f3a5c2d1e0b
+Create Date: 2026-01-29 10:00:00.000000
+
+This migration:
+1. Creates the oauth_accounts table to store multiple OAuth identities per user
+2. Migrates existing oauth data from users table to oauth_accounts
+3. Makes users.email nullable (for providers like Twitter that don't provide email)
+4. Removes oauth_provider and oauth_id columns from users table
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from advanced_alchemy.types import GUID, DateTimeUTC
+
+
+# revision identifiers, used by Alembic.
+revision: str = '1a2b3c4d5e6f'
+down_revision: Union[str, None] = '8f3a5c2d1e0b'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # Step 1: Create oauth_accounts table
+    op.create_table(
+        'oauth_accounts',
+        sa.Column('id', GUID(length=16), nullable=False),
+        sa.Column('created_at', DateTimeUTC(timezone=True), nullable=False),
+        sa.Column('updated_at', DateTimeUTC(timezone=True), nullable=False),
+        sa.Column('sa_orm_sentinel', sa.Integer(), nullable=True),
+        sa.Column('provider', sa.String(length=50), nullable=False),
+        sa.Column('provider_account_id', sa.String(length=255), nullable=False),
+        sa.Column('provider_email', sa.String(length=255), nullable=True),
+        sa.Column('user_id', GUID(length=16), nullable=False),
+        sa.PrimaryKeyConstraint('id', name=op.f('pk_oauth_accounts')),
+        sa.ForeignKeyConstraint(
+            ['user_id'], ['users.id'],
+            name=op.f('fk_oauth_accounts_user_id_users'),
+            ondelete='CASCADE'
+        ),
+        sa.UniqueConstraint(
+            'provider', 'provider_account_id',
+            name='uq_oauth_provider_account'
+        ),
+    )
+    op.create_index(
+        op.f('ix_oauth_accounts_user_id'),
+        'oauth_accounts',
+        ['user_id'],
+        unique=False
+    )
+    op.create_index(
+        op.f('ix_oauth_accounts_provider_account'),
+        'oauth_accounts',
+        ['provider', 'provider_account_id'],
+        unique=True
+    )
+
+    # Step 2: Migrate existing data from users to oauth_accounts
+    # Generate binary UUIDs (16 bytes) for new records and copy oauth data
+    conn = op.get_bind()
+    conn.execute(sa.text("""
+        INSERT INTO oauth_accounts (id, created_at, updated_at, provider, provider_account_id, provider_email, user_id)
+        SELECT
+            randomblob(16),
+            created_at,
+            updated_at,
+            oauth_provider,
+            oauth_id,
+            email,
+            id
+        FROM users
+        WHERE oauth_provider IS NOT NULL AND oauth_id IS NOT NULL
+    """))
+
+    # Step 3: Make email nullable on users table
+    # SQLite doesn't support ALTER COLUMN, so we need to recreate the table
+    # For SQLite, we'll use batch_alter_table
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        # Drop the unique constraint on oauth_id
+        batch_op.drop_constraint('uq_users_oauth_id', type_='unique')
+        # Drop the oauth columns
+        batch_op.drop_column('oauth_provider')
+        batch_op.drop_column('oauth_id')
+        # Make email nullable - this requires recreating the column in SQLite
+        batch_op.alter_column('email',
+                              existing_type=sa.String(length=255),
+                              nullable=True)
+
+
+def downgrade() -> None:
+    # Step 1: Add back oauth columns to users table
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('oauth_provider', sa.String(length=50), nullable=True))
+        batch_op.add_column(sa.Column('oauth_id', sa.String(length=255), nullable=True))
+        batch_op.alter_column('email',
+                              existing_type=sa.String(length=255),
+                              nullable=False)
+
+    # Step 2: Migrate data back from oauth_accounts to users
+    # Only migrate the first oauth account per user
+    conn = op.get_bind()
+    conn.execute(sa.text("""
+        UPDATE users
+        SET oauth_provider = (
+            SELECT provider FROM oauth_accounts
+            WHERE oauth_accounts.user_id = users.id
+            LIMIT 1
+        ),
+        oauth_id = (
+            SELECT provider_account_id FROM oauth_accounts
+            WHERE oauth_accounts.user_id = users.id
+            LIMIT 1
+        )
+    """))
+
+    # Step 3: Make oauth columns non-nullable and add unique constraint
+    with op.batch_alter_table('users', schema=None) as batch_op:
+        batch_op.alter_column('oauth_provider',
+                              existing_type=sa.String(length=50),
+                              nullable=False)
+        batch_op.alter_column('oauth_id',
+                              existing_type=sa.String(length=255),
+                              nullable=False)
+        batch_op.create_unique_constraint('uq_users_oauth_id', ['oauth_id'])
+
+    # Step 4: Drop oauth_accounts table
+    op.drop_index(op.f('ix_oauth_accounts_provider_account'), table_name='oauth_accounts')
+    op.drop_index(op.f('ix_oauth_accounts_user_id'), table_name='oauth_accounts')
+    op.drop_table('oauth_accounts')

skrift/alembic.ini

@@ -1,8 +1,8 @@
 # Alembic Configuration File
 
 [alembic]
-# Path to migration scripts
-script_location = alembic
+# Path to migration scripts (relative to this file)
+script_location = %(here)s/alembic
 
 # Template used to generate migration files
 file_template = %%(year)d%%(month).2d%%(day).2d_%%(hour).2d%%(minute).2d%%(second).2d_%%(rev)s_%%(slug)s

skrift/cli.py

@@ -19,24 +19,33 @@ def db() -> None:
     """
     from alembic.config import main as alembic_main
 
-    # Ensure we're running from the project root where alembic.ini is located
-    # If alembic.ini is not in cwd, check common locations
-    alembic_ini = Path.cwd() / "alembic.ini"
-
+    import os
+
+    # Always run from the project root (where app.yaml and .env are)
+    # This ensures database paths like ./app.db resolve correctly
+    project_root = Path.cwd()
+    if not (project_root / "app.yaml").exists():
+        # If not in project root, try parent directory
+        project_root = Path(__file__).parent.parent
+    os.chdir(project_root)
+
+    # Find alembic.ini - check project root first, then skrift package directory
+    alembic_ini = project_root / "alembic.ini"
     if not alembic_ini.exists():
-        # Try to find alembic.ini relative to this module
-        module_dir = Path(__file__).parent.parent
-        alembic_ini = module_dir / "alembic.ini"
-
-        if alembic_ini.exists():
-            # Change to the directory containing alembic.ini
-            import os
-            os.chdir(module_dir)
-        else:
+        skrift_dir = Path(__file__).parent
+        alembic_ini = skrift_dir / "alembic.ini"
+
+        if not alembic_ini.exists():
             print("Error: Could not find alembic.ini", file=sys.stderr)
             print("Make sure you're running from the project root directory.", file=sys.stderr)
             sys.exit(1)
 
+    # Build argv with config path at the beginning (before any subcommand)
+    # Original argv: ['skrift-db', 'upgrade', 'head']
+    # New argv: ['skrift-db', '-c', '/path/to/alembic.ini', 'upgrade', 'head']
+    new_argv = [sys.argv[0], "-c", str(alembic_ini)] + sys.argv[1:]
+    sys.argv = new_argv
+
     # Pass through all CLI arguments to Alembic
     sys.exit(alembic_main(sys.argv[1:]))
 

skrift/config.py

@@ -9,8 +9,8 @@ from pydantic import BaseModel
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Load .env file early so env vars are available for YAML interpolation
-# Use explicit path to handle subprocess spawning (uvicorn workers)
-_env_file = Path(__file__).parent.parent / ".env"
+# Load from current working directory (where app.yaml lives)
+_env_file = Path.cwd() / ".env"
 load_dotenv(_env_file)
 
 # Pattern to match $VAR_NAME environment variable references

skrift/controllers/auth.py

@@ -18,8 +18,10 @@ from litestar.params import Parameter
 from litestar.response import Redirect, Template as TemplateResponse
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
 
 from skrift.config import get_settings
+from skrift.db.models.oauth_account import OAuthAccount
 from skrift.db.models.user import User
 from skrift.setup.providers import DUMMY_PROVIDER_KEY, OAUTH_PROVIDERS, get_provider_info
 
@@ -315,30 +317,67 @@ class AuthController(Controller):
         if not oauth_id:
             raise HTTPException(status_code=400, detail="Could not determine user ID")
 
-        # Find or create user
+        email = user_data["email"]
+
+        # Step 1: Check if OAuth account already exists
         result = await db_session.execute(
-            select(User).where(User.oauth_id == oauth_id, User.oauth_provider == provider)
+            select(OAuthAccount)
+            .options(selectinload(OAuthAccount.user))
+            .where(OAuthAccount.provider == provider, OAuthAccount.provider_account_id == oauth_id)
         )
-        user = result.scalar_one_or_none()
+        oauth_account = result.scalar_one_or_none()
 
-        if user:
-            # Update existing user
+        if oauth_account:
+            # Existing OAuth account - update user profile
+            user = oauth_account.user
             user.name = user_data["name"]
             if user_data["picture_url"]:
                 user.picture_url = user_data["picture_url"]
             user.last_login_at = datetime.now(UTC)
+            # Update provider email if changed
+            if email:
+                oauth_account.provider_email = email
         else:
-            # Create new user (admin role is only assigned through setup flow)
-            user = User(
-                oauth_provider=provider,
-                oauth_id=oauth_id,
-                email=user_data["email"],
-                name=user_data["name"],
-                picture_url=user_data["picture_url"],
-                last_login_at=datetime.now(UTC),
-            )
-            db_session.add(user)
-            await db_session.flush()
+            # Step 2: Check if a user with this email already exists
+            user = None
+            if email:
+                result = await db_session.execute(
+                    select(User).where(User.email == email)
+                )
+                user = result.scalar_one_or_none()
+
+            if user:
+                # Link new OAuth account to existing user
+                oauth_account = OAuthAccount(
+                    provider=provider,
+                    provider_account_id=oauth_id,
+                    provider_email=email,
+                    user_id=user.id,
+                )
+                db_session.add(oauth_account)
+                # Update user profile
+                user.name = user_data["name"]
+                if user_data["picture_url"]:
+                    user.picture_url = user_data["picture_url"]
+                user.last_login_at = datetime.now(UTC)
+            else:
+                # Step 3: Create new user + OAuth account
+                user = User(
+                    email=email,
+                    name=user_data["name"],
+                    picture_url=user_data["picture_url"],
+                    last_login_at=datetime.now(UTC),
+                )
+                db_session.add(user)
+                await db_session.flush()
+
+                oauth_account = OAuthAccount(
+                    provider=provider,
+                    provider_account_id=oauth_id,
+                    provider_email=email,
+                    user_id=user.id,
+                )
+                db_session.add(oauth_account)
 
         await db_session.commit()
 
@@ -405,31 +444,60 @@ class AuthController(Controller):
         # Generate deterministic oauth_id from email
         oauth_id = f"dummy_{hashlib.sha256(email.encode()).hexdigest()[:16]}"
 
-        # Find or create user
+        # Step 1: Check if OAuth account already exists
         result = await db_session.execute(
-            select(User).where(
-                User.oauth_id == oauth_id,
-                User.oauth_provider == DUMMY_PROVIDER_KEY,
+            select(OAuthAccount)
+            .options(selectinload(OAuthAccount.user))
+            .where(
+                OAuthAccount.provider == DUMMY_PROVIDER_KEY,
+                OAuthAccount.provider_account_id == oauth_id,
             )
         )
-        user = result.scalar_one_or_none()
+        oauth_account = result.scalar_one_or_none()
 
-        if user:
-            # Update existing user
+        if oauth_account:
+            # Existing OAuth account - update user profile
+            user = oauth_account.user
             user.name = name
             user.email = email
             user.last_login_at = datetime.now(UTC)
+            oauth_account.provider_email = email
         else:
-            # Create new user
-            user = User(
-                oauth_provider=DUMMY_PROVIDER_KEY,
-                oauth_id=oauth_id,
-                email=email,
-                name=name,
-                last_login_at=datetime.now(UTC),
+            # Step 2: Check if a user with this email already exists
+            result = await db_session.execute(
+                select(User).where(User.email == email)
             )
-            db_session.add(user)
-            await db_session.flush()
+            user = result.scalar_one_or_none()
+
+            if user:
+                # Link new OAuth account to existing user
+                oauth_account = OAuthAccount(
+                    provider=DUMMY_PROVIDER_KEY,
+                    provider_account_id=oauth_id,
+                    provider_email=email,
+                    user_id=user.id,
+                )
+                db_session.add(oauth_account)
+                # Update user profile
+                user.name = name
+                user.last_login_at = datetime.now(UTC)
+            else:
+                # Step 3: Create new user + OAuth account
+                user = User(
+                    email=email,
+                    name=name,
+                    last_login_at=datetime.now(UTC),
+                )
+                db_session.add(user)
+                await db_session.flush()
+
+                oauth_account = OAuthAccount(
+                    provider=DUMMY_PROVIDER_KEY,
+                    provider_account_id=oauth_id,
+                    provider_email=email,
+                    user_id=user.id,
+                )
+                db_session.add(oauth_account)
 
         await db_session.commit()
 

skrift/db/models/__init__.py

@@ -1,6 +1,7 @@
+from skrift.db.models.oauth_account import OAuthAccount
 from skrift.db.models.page import Page
 from skrift.db.models.role import Role, RolePermission, user_roles
 from skrift.db.models.setting import Setting
 from skrift.db.models.user import User
 
-__all__ = ["Page", "Role", "RolePermission", "Setting", "User", "user_roles"]
+__all__ = ["OAuthAccount", "Page", "Role", "RolePermission", "Setting", "User", "user_roles"]

skrift/db/models/oauth_account.py

@@ -0,0 +1,37 @@
+"""OAuth account model for storing multiple OAuth identities per user."""
+
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from skrift.db.base import Base
+
+if TYPE_CHECKING:
+    from skrift.db.models.user import User
+
+
+class OAuthAccount(Base):
+    """OAuth account model linking OAuth provider identities to users.
+
+    This allows a single user to have multiple OAuth provider accounts
+    linked to their profile, enabling login via different providers.
+    """
+
+    __tablename__ = "oauth_accounts"
+
+    provider: Mapped[str] = mapped_column(String(50), nullable=False)
+    provider_account_id: Mapped[str] = mapped_column(String(255), nullable=False)
+    provider_email: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    user_id: Mapped[UUID] = mapped_column(
+        ForeignKey("users.id", ondelete="CASCADE"), nullable=False
+    )
+
+    user: Mapped["User"] = relationship("User", back_populates="oauth_accounts")
+
+    __table_args__ = (
+        UniqueConstraint(
+            "provider", "provider_account_id", name="uq_oauth_provider_account"
+        ),
+    )

skrift/db/models/user.py

@@ -7,6 +7,7 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 from skrift.db.base import Base
 
 if TYPE_CHECKING:
+    from skrift.db.models.oauth_account import OAuthAccount
     from skrift.db.models.page import Page
     from skrift.db.models.role import Role
 
@@ -16,12 +17,8 @@ class User(Base):
 
     __tablename__ = "users"
 
-    # OAuth identifiers
-    oauth_provider: Mapped[str] = mapped_column(String(50), nullable=False)
-    oauth_id: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
-
     # Profile data from OAuth provider
-    email: Mapped[str] = mapped_column(String(255), nullable=False, unique=True)
+    email: Mapped[str | None] = mapped_column(String(255), nullable=True, unique=True)
     name: Mapped[str | None] = mapped_column(String(255), nullable=True)
     picture_url: Mapped[str | None] = mapped_column(String(512), nullable=True)
 
@@ -30,6 +27,9 @@ class User(Base):
     last_login_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
 
     # Relationships
+    oauth_accounts: Mapped[list["OAuthAccount"]] = relationship(
+        "OAuthAccount", back_populates="user", cascade="all, delete-orphan"
+    )
     pages: Mapped[list["Page"]] = relationship("Page", back_populates="user")
     roles: Mapped[list["Role"]] = relationship(
         "Role", secondary="user_roles", back_populates="users", lazy="selectin"

skrift/setup/controller.py

@@ -1,12 +1,13 @@
 """Setup wizard controller for first-time Skrift configuration."""
 
+import asyncio
 import base64
 import hashlib
+import json
 import secrets
-import subprocess
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from datetime import UTC, datetime
-from pathlib import Path
 from urllib.parse import urlencode
 
 import httpx
@@ -16,9 +17,12 @@ from litestar import Controller, Request, get, post
 from litestar.exceptions import HTTPException
 from litestar.params import Parameter
 from litestar.response import Redirect, Template as TemplateResponse
-from sqlalchemy import func, select
+from litestar.response.sse import ServerSentEvent
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine, async_sessionmaker
+from sqlalchemy.orm import selectinload
 
+from skrift.db.models.oauth_account import OAuthAccount
 from skrift.db.models.role import Role, user_roles
 from skrift.db.models.user import User
 from skrift.db.services import setting_service
@@ -32,7 +36,15 @@ from skrift.setup.config_writer import (
     update_database_config,
 )
 from skrift.setup.providers import get_all_providers, get_provider_info
-from skrift.setup.state import can_connect_to_database, app_yaml_exists, get_database_url_from_yaml
+from skrift.setup.state import (
+    can_connect_to_database,
+    get_database_url_from_yaml,
+    get_first_incomplete_step,
+    is_auth_configured,
+    is_site_configured,
+    run_migrations_if_needed,
+    reset_migrations_flag,
+)
 
 
 @asynccontextmanager
@@ -75,27 +87,32 @@ class SetupController(Controller):
 
     @get("/")
     async def index(self, request: Request) -> Redirect:
-        """Redirect to appropriate setup step."""
-        # Check wizard progress from session
-        wizard_step = request.session.get("setup_wizard_step", "database")
-
-        # If we don't have app.yaml or db isn't configured, start at database
-        if not app_yaml_exists():
-            return Redirect(path="/setup/database")
+        """Redirect to the first incomplete setup step.
 
+        Uses smart detection to skip already-configured steps, allowing users
+        to resume setup without re-entering existing configuration.
+        """
+        # Check if database is configured and connectable
         can_connect, _ = await can_connect_to_database()
-        if not can_connect:
-            return Redirect(path="/setup/database")
+        if can_connect:
+            # Database is configured - go through configuring page to run migrations
+            return Redirect(path="/setup/configuring")
 
-        # Otherwise go to the saved step
-        return Redirect(path=f"/setup/{wizard_step}")
+        # Database not configured - go to database step
+        request.session["setup_wizard_step"] = "database"
+        return Redirect(path="/setup/database")
 
     @get("/database")
-    async def database_step(self, request: Request) -> TemplateResponse:
+    async def database_step(self, request: Request) -> TemplateResponse | Redirect:
         """Step 1: Database configuration."""
         flash = request.session.pop("flash", None)
         error = request.session.pop("setup_error", None)
 
+        # If database is already configured and no errors, go to configuring page
+        can_connect, _ = await can_connect_to_database()
+        if can_connect and not error:
+            return Redirect(path="/setup/configuring")
+
         # Load current config if exists
         config = load_config()
         db_config = config.get("db", {})
@@ -167,41 +184,9 @@ class SetupController(Controller):
                 request.session["setup_error"] = f"Connection failed: {error}"
                 return Redirect(path="/setup/database")
 
-            # Run migrations
-            try:
-                result = subprocess.run(
-                    ["skrift-db", "upgrade", "head"],
-                    capture_output=True,
-                    text=True,
-                    cwd=Path.cwd(),
-                    timeout=60,
-                )
-                if result.returncode != 0:
-                    request.session["setup_error"] = f"Migration failed: {result.stderr}"
-                    return Redirect(path="/setup/database")
-            except subprocess.TimeoutExpired:
-                request.session["setup_error"] = "Migration timed out"
-                return Redirect(path="/setup/database")
-            except FileNotFoundError:
-                # skrift-db might not be installed yet, try alembic directly
-                try:
-                    result = subprocess.run(
-                        ["alembic", "upgrade", "head"],
-                        capture_output=True,
-                        text=True,
-                        cwd=Path.cwd(),
-                        timeout=60,
-                    )
-                    if result.returncode != 0:
-                        request.session["setup_error"] = f"Migration failed: {result.stderr}"
-                        return Redirect(path="/setup/database")
-                except Exception as e:
-                    request.session["setup_error"] = f"Could not run migrations: {e}"
-                    return Redirect(path="/setup/database")
-
-            request.session["setup_wizard_step"] = "auth"
-            request.session["flash"] = "Database configured successfully!"
-            return Redirect(path="/setup/auth")
+            # Connection successful - redirect to configuring page to run migrations
+            request.session["setup_wizard_step"] = "configuring"
+            return Redirect(path="/setup/configuring")
 
         except Exception as e:
             request.session["setup_error"] = str(e)
@@ -213,12 +198,116 @@ class SetupController(Controller):
         request.session["setup_wizard_step"] = "auth"
         return Redirect(path="/setup/auth")
 
+    @get("/configuring")
+    async def configuring_step(self, request: Request) -> TemplateResponse | Redirect:
+        """Database configuration in progress page.
+
+        Shows a loading spinner while migrations run via SSE.
+        """
+        flash = request.session.pop("flash", None)
+        error = request.session.pop("setup_error", None)
+
+        # Verify we can connect to the database first
+        can_connect, connection_error = await can_connect_to_database()
+        if not can_connect:
+            request.session["setup_error"] = f"Cannot connect to database: {connection_error}"
+            return Redirect(path="/setup/database")
+
+        # Reset migrations flag so they run fresh via SSE
+        reset_migrations_flag()
+
+        return TemplateResponse(
+            "setup/configuring.html",
+            context={
+                "flash": flash,
+                "error": error,
+                "step": 1,
+                "total_steps": 4,
+            },
+        )
+
+    @get("/configuring/status")
+    async def configuring_status(self, request: Request) -> ServerSentEvent:
+        """SSE endpoint for database configuration status.
+
+        Streams migration progress and completion status.
+        """
+        async def generate_status() -> AsyncGenerator[str, None]:
+            # Send initial status
+            yield json.dumps({
+                "status": "running",
+                "message": "Testing database connection...",
+                "detail": "",
+            })
+
+            await asyncio.sleep(0.5)
+
+            # Test connection
+            can_connect, connection_error = await can_connect_to_database()
+            if not can_connect:
+                yield json.dumps({
+                    "status": "error",
+                    "message": f"Database connection failed: {connection_error}",
+                })
+                return
+
+            yield json.dumps({
+                "status": "running",
+                "message": "Running database migrations...",
+                "detail": "This may take a moment",
+            })
+
+            await asyncio.sleep(0.3)
+
+            # Run migrations
+            success, error = run_migrations_if_needed()
+
+            if not success:
+                yield json.dumps({
+                    "status": "error",
+                    "message": f"Migration failed: {error}",
+                })
+                return
+
+            yield json.dumps({
+                "status": "running",
+                "message": "Verifying database schema...",
+                "detail": "",
+            })
+
+            await asyncio.sleep(0.3)
+
+            # Determine next step
+            if is_auth_configured():
+                if await is_site_configured():
+                    next_step = "admin"
+                else:
+                    next_step = "site"
+            else:
+                next_step = "auth"
+
+            # All done - include next step
+            yield json.dumps({
+                "status": "complete",
+                "message": "Database configured successfully!",
+                "next_step": next_step,
+            })
+
+        return ServerSentEvent(generate_status())
+
     @get("/auth")
-    async def auth_step(self, request: Request) -> TemplateResponse:
+    async def auth_step(self, request: Request) -> TemplateResponse | Redirect:
         """Step 2: Authentication providers."""
         flash = request.session.pop("flash", None)
         error = request.session.pop("setup_error", None)
 
+        # If auth is already configured and no errors, skip to next step
+        if is_auth_configured() and not error:
+            next_step = await get_first_incomplete_step()
+            if next_step.value != "auth":
+                request.session["setup_wizard_step"] = next_step.value
+                return Redirect(path=f"/setup/{next_step.value}")
+
         # Get current redirect URL from request
         scheme = request.headers.get("x-forwarded-proto", request.url.scheme)
         host = request.headers.get("host", request.url.netloc)
@@ -291,20 +380,29 @@ class SetupController(Controller):
                 use_env_vars=use_env_vars,
             )
 
-            request.session["setup_wizard_step"] = "site"
+            # Determine next step using smart detection
+            next_step = await get_first_incomplete_step()
+            request.session["setup_wizard_step"] = next_step.value
             request.session["flash"] = "Authentication configured successfully!"
-            return Redirect(path="/setup/site")
+            return Redirect(path=f"/setup/{next_step.value}")
 
         except Exception as e:
             request.session["setup_error"] = str(e)
             return Redirect(path="/setup/auth")
 
     @get("/site")
-    async def site_step(self, request: Request) -> TemplateResponse:
+    async def site_step(self, request: Request) -> TemplateResponse | Redirect:
         """Step 3: Site settings."""
         flash = request.session.pop("flash", None)
         error = request.session.pop("setup_error", None)
 
+        # If site is already configured and no errors, skip to next step
+        if await is_site_configured() and not error:
+            next_step = await get_first_incomplete_step()
+            if next_step.value != "site":
+                request.session["setup_wizard_step"] = next_step.value
+                return Redirect(path=f"/setup/{next_step.value}")
+
         return TemplateResponse(
             "setup/site.html",
             context={
@@ -356,9 +454,11 @@ class SetupController(Controller):
                 # Reload cache
                 await setting_service.load_site_settings_cache(db_session)
 
-            request.session["setup_wizard_step"] = "admin"
+            # Determine next step using smart detection - should be admin at this point
+            next_step = await get_first_incomplete_step()
+            request.session["setup_wizard_step"] = next_step.value
             request.session["flash"] = "Site settings saved!"
-            return Redirect(path="/setup/admin")
+            return Redirect(path=f"/setup/{next_step.value}")
 
         except Exception as e:
             request.session["setup_error"] = str(e)
@@ -621,31 +721,68 @@ class SetupAuthController(Controller):
         if not oauth_id:
             raise HTTPException(status_code=400, detail="Could not determine user ID")
 
+        email = user_data["email"]
+
         # Create user and mark setup complete
         async with get_setup_db_session() as db_session:
-            # Check if user exists
+            # Step 1: Check if OAuth account already exists
             result = await db_session.execute(
-                select(User).where(User.oauth_id == oauth_id, User.oauth_provider == provider)
+                select(OAuthAccount)
+                .options(selectinload(OAuthAccount.user))
+                .where(OAuthAccount.provider == provider, OAuthAccount.provider_account_id == oauth_id)
             )
-            user = result.scalar_one_or_none()
+            oauth_account = result.scalar_one_or_none()
 
-            if user:
+            if oauth_account:
+                # Existing OAuth account - update user profile
+                user = oauth_account.user
                 user.name = user_data["name"]
                 if user_data["picture_url"]:
                     user.picture_url = user_data["picture_url"]
                 user.last_login_at = datetime.now(UTC)
+                if email:
+                    oauth_account.provider_email = email
             else:
-                # Create new user
-                user = User(
-                    oauth_provider=provider,
-                    oauth_id=oauth_id,
-                    email=user_data["email"],
-                    name=user_data["name"],
-                    picture_url=user_data["picture_url"],
-                    last_login_at=datetime.now(UTC),
-                )
-                db_session.add(user)
-                await db_session.flush()
+                # Step 2: Check if a user with this email already exists
+                user = None
+                if email:
+                    result = await db_session.execute(
+                        select(User).where(User.email == email)
+                    )
+                    user = result.scalar_one_or_none()
+
+                if user:
+                    # Link new OAuth account to existing user
+                    oauth_account = OAuthAccount(
+                        provider=provider,
+                        provider_account_id=oauth_id,
+                        provider_email=email,
+                        user_id=user.id,
+                    )
+                    db_session.add(oauth_account)
+                    # Update user profile
+                    user.name = user_data["name"]
+                    if user_data["picture_url"]:
+                        user.picture_url = user_data["picture_url"]
+                    user.last_login_at = datetime.now(UTC)
+                else:
+                    # Step 3: Create new user + OAuth account
+                    user = User(
+                        email=email,
+                        name=user_data["name"],
+                        picture_url=user_data["picture_url"],
+                        last_login_at=datetime.now(UTC),
+                    )
+                    db_session.add(user)
+                    await db_session.flush()
+
+                    oauth_account = OAuthAccount(
+                        provider=provider,
+                        provider_account_id=oauth_id,
+                        provider_email=email,
+                        user_id=user.id,
+                    )
+                    db_session.add(oauth_account)
 
             # Ensure roles are synced (they may not exist if DB was created after server start)
             from skrift.auth import sync_roles_to_database

skrift/setup/state.py

@@ -3,17 +3,36 @@
 This module implements a two-tier detection strategy:
 1. Pre-database check: Can we connect to a database?
 2. Post-database check: Is setup complete (check for setup_completed_at setting)?
+
+Smart step detection: If config is already present, skip to the first incomplete step.
 """
 
 import os
+import subprocess
 from enum import Enum
 from pathlib import Path
-
+import yaml
 from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
 
+# Track if migrations have been run this session to avoid running multiple times
+_migrations_run = False
+
+
+def reset_migrations_flag() -> None:
+    """Reset the migrations flag to allow re-running migrations.
+
+    Call this when starting the configuring page to ensure migrations run fresh.
+    """
+    global _migrations_run
+    _migrations_run = False
+
 from skrift.config import get_config_path
-from skrift.db.services.setting_service import SETUP_COMPLETED_AT_KEY, get_setting
+from skrift.db.services.setting_service import (
+    SETUP_COMPLETED_AT_KEY,
+    SITE_NAME_KEY,
+    get_setting,
+)
 
 
 class SetupStep(Enum):
@@ -103,6 +122,167 @@ async def is_setup_complete(db_session: AsyncSession) -> bool:
         return False
 
 
+def is_auth_configured() -> bool:
+    """Check if at least one OAuth provider is fully configured in app.yaml.
+
+    A provider is considered configured if it has both client_id and client_secret.
+
+    Returns:
+        True if at least one provider is configured, False otherwise.
+    """
+    config_path = get_config_path()
+    if not config_path.exists():
+        return False
+
+    try:
+        with open(config_path, "r") as f:
+            config = yaml.safe_load(f)
+
+        if not config:
+            return False
+
+        auth = config.get("auth", {})
+        providers = auth.get("providers", {})
+
+        for _, provider_config in providers.items():
+            if not isinstance(provider_config, dict):
+                continue
+            # Check if provider has both client_id and client_secret (even as env var refs)
+            client_id = provider_config.get("client_id", "")
+            client_secret = provider_config.get("client_secret", "")
+            if client_id and client_secret:
+                return True
+
+        return False
+    except Exception:
+        return False
+
+
+def run_migrations_if_needed() -> tuple[bool, str | None]:
+    """Run database migrations if they haven't been run this session.
+
+    This ensures the database schema is up to date before checking for
+    settings or other database-dependent configuration.
+
+    Returns:
+        Tuple of (success, error_message)
+    """
+    global _migrations_run
+    if _migrations_run:
+        return True, None
+
+    try:
+        # Try skrift-db first
+        result = subprocess.run(
+            ["skrift-db", "upgrade", "head"],
+            capture_output=True,
+            text=True,
+            cwd=Path.cwd(),
+            timeout=60,
+        )
+        if result.returncode == 0:
+            _migrations_run = True
+            return True, None
+        # If skrift-db fails, try alembic directly
+    except (subprocess.TimeoutExpired, FileNotFoundError):
+        pass
+
+    try:
+        result = subprocess.run(
+            ["alembic", "upgrade", "head"],
+            capture_output=True,
+            text=True,
+            cwd=Path.cwd(),
+            timeout=60,
+        )
+        if result.returncode == 0:
+            _migrations_run = True
+            return True, None
+        return False, result.stderr
+    except subprocess.TimeoutExpired:
+        return False, "Migration timed out"
+    except FileNotFoundError:
+        return False, "Neither skrift-db nor alembic found"
+    except Exception as e:
+        return False, str(e)
+
+
+async def is_site_configured() -> bool:
+    """Check if site settings have been configured in the database.
+
+    The site step is considered complete if site_name has been set.
+    Returns False if the settings table doesn't exist yet (pre-migration).
+
+    Returns:
+        True if site is configured, False otherwise.
+    """
+    db_url = get_database_url_from_yaml()
+    if not db_url:
+        return False
+
+    engine = None
+    try:
+        engine = create_async_engine(db_url)
+        from sqlalchemy.ext.asyncio import async_sessionmaker
+
+        async_session = async_sessionmaker(engine, expire_on_commit=False)
+        async with async_session() as session:
+            try:
+                site_name = await get_setting(session, SITE_NAME_KEY)
+                return site_name is not None
+            except Exception:
+                # Table might not exist yet (before migration)
+                return False
+    except Exception:
+        return False
+    finally:
+        if engine:
+            await engine.dispose()
+
+
+async def get_first_incomplete_step() -> SetupStep:
+    """Determine the first incomplete step in the setup wizard.
+
+    This function checks configuration completeness for each step and returns
+    the first step that needs to be completed. Use this to skip already-configured
+    steps when the user is forced back into the setup wizard.
+
+    If database is configured and connectable, runs migrations to ensure
+    all tables exist before checking database-dependent configuration.
+
+    Returns:
+        The first setup step that needs user input.
+    """
+    # Step 1: Database - check if we can connect
+    if not app_yaml_exists():
+        return SetupStep.DATABASE
+
+    db_url = get_database_url_from_yaml()
+    if not db_url:
+        return SetupStep.DATABASE
+
+    can_connect, _ = await can_connect_to_database()
+    if not can_connect:
+        return SetupStep.DATABASE
+
+    # Database is configured and connectable - run migrations to ensure tables exist
+    migration_success, _ = run_migrations_if_needed()
+    if not migration_success:
+        # If migrations fail, go back to database step to show the error
+        return SetupStep.DATABASE
+
+    # Step 2: Auth - check if at least one provider is configured
+    if not is_auth_configured():
+        return SetupStep.AUTH
+
+    # Step 3: Site - check if site settings exist in DB
+    if not await is_site_configured():
+        return SetupStep.SITE
+
+    # Step 4: Admin - always go here if setup not complete
+    return SetupStep.ADMIN
+
+
 async def get_setup_step(db_session: AsyncSession | None = None) -> SetupStep:
     """Determine which setup step the user should be on.
 

skrift/templates/setup/configuring.html

@@ -0,0 +1,158 @@
+{% extends "setup/base.html" %}
+
+{% block title %}Configuring Database - Skrift{% endblock %}
+
+{% block head %}
+<style>
+    .configuring-content {
+        text-align: center;
+        padding: 2rem 0;
+    }
+
+    .spinner {
+        width: 48px;
+        height: 48px;
+        border: 4px solid var(--color-border);
+        border-top-color: var(--color-primary);
+        border-radius: 50%;
+        animation: spin 1s linear infinite;
+        margin: 0 auto 1.5rem;
+    }
+
+    .spinner.complete {
+        border-color: var(--color-success);
+        border-top-color: var(--color-success);
+        animation: none;
+    }
+
+    .spinner.error {
+        border-color: var(--color-error);
+        border-top-color: var(--color-error);
+        animation: none;
+    }
+
+    @keyframes spin {
+        to { transform: rotate(360deg); }
+    }
+
+    .status-icon {
+        width: 48px;
+        height: 48px;
+        margin: 0 auto 1.5rem;
+        font-size: 48px;
+        line-height: 1;
+        display: none;
+    }
+
+    .status-icon.complete {
+        display: block;
+        color: var(--color-success);
+    }
+
+    .status-icon.error {
+        display: block;
+        color: var(--color-error);
+    }
+
+    .status-message {
+        font-size: 1.125rem;
+        margin-bottom: 0.5rem;
+    }
+
+    .status-detail {
+        color: var(--color-text-muted);
+        font-size: 0.875rem;
+        min-height: 1.25rem;
+    }
+
+    .form-actions button:disabled {
+        opacity: 0.5;
+        cursor: not-allowed;
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+<h2>Configuring Database</h2>
+<p class="description">Setting up your database and running migrations.</p>
+
+<div class="configuring-content">
+    <div class="spinner" id="spinner"></div>
+    <div class="status-icon" id="status-icon"></div>
+    <div class="status-message" id="status-message">Initializing...</div>
+    <div class="status-detail" id="status-detail"></div>
+</div>
+
+<div class="form-actions">
+    <a href="/setup/database" role="button" class="btn-secondary">Back</a>
+    <button type="button" id="next-button" disabled>Continue</button>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+    document.addEventListener('DOMContentLoaded', function() {
+        const spinner = document.getElementById('spinner');
+        const statusIcon = document.getElementById('status-icon');
+        const statusMessage = document.getElementById('status-message');
+        const statusDetail = document.getElementById('status-detail');
+        const nextButton = document.getElementById('next-button');
+
+        let nextStep = 'auth'; // Default fallback
+
+        function setComplete(step) {
+            spinner.style.display = 'none';
+            statusIcon.textContent = '\u2713';
+            statusIcon.classList.add('complete');
+            statusMessage.textContent = 'Database configured successfully!';
+            statusDetail.textContent = '';
+            nextButton.disabled = false;
+            if (step) {
+                nextStep = step;
+            }
+            nextButton.onclick = function() {
+                window.location.href = '/setup/' + nextStep;
+            };
+        }
+
+        function setError(message) {
+            spinner.style.display = 'none';
+            statusIcon.textContent = '\u2717';
+            statusIcon.classList.add('error');
+            statusMessage.textContent = 'Configuration failed';
+            statusDetail.textContent = message || 'An error occurred during setup.';
+        }
+
+        function setStatus(message, detail) {
+            statusMessage.textContent = message;
+            statusDetail.textContent = detail || '';
+        }
+
+        // Connect to SSE endpoint
+        const eventSource = new EventSource('/setup/configuring/status');
+
+        eventSource.onmessage = function(event) {
+            const data = JSON.parse(event.data);
+
+            if (data.status === 'running') {
+                setStatus(data.message, data.detail);
+            } else if (data.status === 'complete') {
+                setComplete(data.next_step);
+                eventSource.close();
+            } else if (data.status === 'error') {
+                setError(data.message);
+                eventSource.close();
+            }
+        };
+
+        eventSource.onerror = function() {
+            // Check if we were successful before the connection closed
+            if (!nextButton.disabled) {
+                return; // Already complete, ignore the error
+            }
+            setError('Connection lost. Please refresh the page.');
+            eventSource.close();
+        };
+    });
+</script>
+{% endblock %}

{skrift-0.1.0a2.dist-info → skrift-0.1.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skrift
-Version: 0.1.0a2
+Version: 0.1.0a4
 Summary: A lightweight async Python CMS for crafting modern websites
 Requires-Python: >=3.13
 Requires-Dist: advanced-alchemy>=0.26.0

{skrift-0.1.0a2.dist-info → skrift-0.1.0a4.dist-info}/RECORD

@@ -1,33 +1,35 @@
 skrift/__init__.py,sha256=eXE5PFVkJpH5XsV_ZlrTIeFPUPrmcHYAj4GpRS3R5PY,29
 skrift/__main__.py,sha256=Fs17xxkqTjZpJn9MMC6pzkW4sOzNhV5RGLsA2ONPFww,271
-skrift/alembic.ini,sha256=aq1sNDUgKvdON-N28lN9fncRcYtg430HE2DsuEMIDtk,1782
+skrift/alembic.ini,sha256=mYguI6CbMCTyfHctsGiTyf9Z5gv21FdeI3qtfgOHO3A,1815
 skrift/asgi.py,sha256=U-9p_JlWlwjrhKJzAlBHpQ3DvTB2uIcvZe3-5Gs87Ec,19248
-skrift/cli.py,sha256=rrm0cSc2LhQ1FA5-ucDN1sDTwFwKnDk1DCYf746SYyo,1522
-skrift/config.py,sha256=7Jqqm9jXff7rIRY83C4jchDVk_1UkpGdKATX3JgX974,7423
+skrift/cli.py,sha256=DB_MssHeBAvpm7DVgd3V-BQr5BjBqSO0O_0vm15PZJ8,1941
+skrift/config.py,sha256=_fXfdRdy03yJWUhijthC4cNgOXLJ0jhB__C-VwVYaxc,7398
 skrift/admin/__init__.py,sha256=x81Cj_ilVmv6slaMl16HHyT_AgrnLxKEWkS0RPa4V9s,289
 skrift/admin/controller.py,sha256=5ZDypvKHXLNDESsKNsdsH2E3Si5OqlpzttFl7Ot8aF0,15651
 skrift/admin/navigation.py,sha256=VwttFoIUIJy5rONKIkJd5w4CNkUpeK22_OfLGHecN34,3382
-skrift/alembic/env.py,sha256=vYy8dBm7zW8F5izsQdVgQyJ6yGmRbqUfGoWgefD49vQ,2609
+skrift/alembic/env.py,sha256=GaQx7D-3f0zVTV4YJNhN0GOfqHL99N4VBfMzjZJz0Bc,2673
 skrift/alembic/script.py.mako,sha256=MEqL-2qATlST9TAOeYgscMn1uy6HUS9NFvDgl93dMj8,635
 skrift/alembic/versions/20260120_210154_09b0364dbb7b_initial_schema.py,sha256=X6w1vbVKFurhEcblTLGO4Nd_IKkMVtb8TsptV4gpAJ4,2750
 skrift/alembic/versions/20260122_152744_0b7c927d2591_add_roles_and_permissions.py,sha256=yCGjnMTpfSMHVYQCsPTD6wdDI8pJSUtGRESO6bz0KfU,2672
 skrift/alembic/versions/20260122_172836_cdf734a5b847_add_sa_orm_sentinel_column.py,sha256=96TCvvQbYk3RGpZdEQ0x4bIDXxBLc3Gv7VTItTq9T54,850
 skrift/alembic/versions/20260122_175637_a9c55348eae7_remove_page_type_column.py,sha256=XJ55LhwzgN07MAREk6w4Bx2Vu3KvMe_bDkIjgE6EfqM,1223
 skrift/alembic/versions/20260122_200000_add_settings_table.py,sha256=aG4pxp18fwonGAWt7EoT0XaiIEmu7zltSrj8e2a8QZU,1310
+skrift/alembic/versions/20260129_add_oauth_accounts.py,sha256=SJYQl0cfyJnUKLzsbGqu97Kcm7waPhxmpyARJXB3Z1Q,5240
 skrift/auth/__init__.py,sha256=uHMqty3dgDSYlReVT96WhygzH6qNAWSVDWoxumzxmsA,1155
 skrift/auth/guards.py,sha256=QePajHsGnJ4R_hlhzblr5IoAgZcY5jzeZ64bJwDL9hM,4451
 skrift/auth/roles.py,sha256=jpqK4qaavqAhJRxhptm2x5mUb6KkwEALaml8sEH4Sug,2267
 skrift/auth/services.py,sha256=h6GTXdN5UMRYglnaFz4asMoutVkSSAyL3_Vt56N26pA,5441
 skrift/controllers/__init__.py,sha256=bVr0tsSGz7jBi002Lqd1AA1FQd7ZA_IagsqTKpiHiK0,147
-skrift/controllers/auth.py,sha256=3rECj_bfpISngcoUfMI3TcqxsmnTlpjMHfVNpMjDG4I,16050
+skrift/controllers/auth.py,sha256=2XQSljDnqdk1NZZTfYLBAqfZb4Ref2p3Uy2maUkKJgY,18881
 skrift/controllers/web.py,sha256=vmoBS1u5G9gCBu65S49yqZn_WBKlmsqlcvX5tYXTKnE,2348
 skrift/db/__init__.py,sha256=uSghyDFT2K4SFiEqUzdjCGzWpS-Oy6Sd1FUappau-v0,52
 skrift/db/base.py,sha256=QJplFj9235kZdScASEpvyNHln6YW2hqbHwJEYZ3OSsc,173
-skrift/db/models/__init__.py,sha256=8ivPDjVMDZPvl06ZWBjp4YmSfC4qhbq76PDJ8MWqzv4,269
+skrift/db/models/__init__.py,sha256=wFF9YWe7rhIWIzRuMtAWVDcZdJsNcKnjfhKbLZw9JVs,341
+skrift/db/models/oauth_account.py,sha256=kLb-1Do8a7tluW3f-uhA_BpgkZ9h10kg_8v0jInDrwY,1216
 skrift/db/models/page.py,sha256=CI5W2sWq0zbKHxfwH5TpmGdJ4zlTicckzpdZtaqjJVE,1019
 skrift/db/models/role.py,sha256=VkwkF3XWemmFtkUpQRk6RTIBfcukrU-0PUPCeo8x834,1768
 skrift/db/models/setting.py,sha256=Am4HTyq2LFR408R6BZb--slys1xM8YLYq9HTq_gybD0,392
-skrift/db/models/user.py,sha256=zqZ-sYcYa0StFsSGsPcovy7EpswFo_PtrObBJ8TyHiA,1310
+skrift/db/models/user.py,sha256=kkR3h0CphUyvOGJOpiZH6Qp28LqW2OriwVTfybs7vuY,1338
 skrift/db/services/__init__.py,sha256=qAC24IPOYg6AampUWonmLeajljQRMwUw0lgXksQG6Nk,69
 skrift/db/services/page_service.py,sha256=cXJ-urV7LjUDoVsT1P52f6wcOsur3T-pvqKkGG4xlvI,5246
 skrift/db/services/setting_service.py,sha256=eqFxukn8QFrDHQbaBILOLjP1nr34JPIPFT_NnhmeaTY,5613
@@ -36,10 +38,10 @@ skrift/lib/exceptions.py,sha256=p8ceLIQCc7agCwW6-mhBDAuMAMxZDcf9TDLC6PfztU4,5803
 skrift/lib/template.py,sha256=4_urkRfvth75yNeQ5TyGTHvkvs3vVef7TcwZx0k285k,4226
 skrift/setup/__init__.py,sha256=3VjFPMES5y0M5cQ9R4C1xazqiEPEDqTPjX9-3rBMXnA,478
 skrift/setup/config_writer.py,sha256=YFH3FVjXN7Rum2fzGVPAQRkjdc9b0bHECDqMKYiEkhg,6347
-skrift/setup/controller.py,sha256=HZs6Q2lNdvNh-JakmznMVL-1sj_6wD9axr3ESL1iIaA,29202
+skrift/setup/controller.py,sha256=v0Ey8T7ptJ5A3vOqQ1TUAXH1bQwA0288J5uyUWMihsw,34250
 skrift/setup/middleware.py,sha256=Nai8ZG2vHldngmAhq7kWzAwKRNcP5tHKhJHa5dCh404,2941
 skrift/setup/providers.py,sha256=0BFKB6168NcmtXxFF6ofHgEDMQD2FbXkexsqrARVtDI,7967
-skrift/setup/state.py,sha256=cQT0LIBFHRHpTzbgsBUO5a4iqAlUSAyUeH3m1k6C95w,3739
+skrift/setup/state.py,sha256=RMe9LtIjzDoOm9u-Nk5-KAnr_JBiQIjWDpTP9E30ezc,9304
 skrift/static/css/style.css,sha256=sJ7-y8nrUdB5EB5_CyjWo1CTnqmYq0UgMZYMjxw0988,20824
 skrift/templates/base.html,sha256=4bg4s4VdES0dSvhJYLgrfrN26ynqeq1-3jyKPkWWVWk,2065
 skrift/templates/error-404.html,sha256=sJrDaF3Or3Nyki8mxo3wBxLLzgy4wkB9p9wdS8pRA6k,409
@@ -60,10 +62,11 @@ skrift/templates/setup/admin.html,sha256=BSIztZT2iqxVSW23Tfg7ZM51SdGrKL422CR05DP
 skrift/templates/setup/auth.html,sha256=0DVL0kU6DlJ2pWe4zwc3DsIVfBAdqpMJxPYvS4zm4OM,4953
 skrift/templates/setup/base.html,sha256=LTXqbnHMvx1wDsxFvo4BSieBPD9pcLMj6NM4ZGzErFM,10372
 skrift/templates/setup/complete.html,sha256=oyT-rYPl0uuyOjPXgNeLr8YoptW9QjHTlScZSViDvTk,630
+skrift/templates/setup/configuring.html,sha256=2KHW9h2BrJgL_kO5IizbAYs4pnFLyRf76IQvEj_cNRM,4607
 skrift/templates/setup/database.html,sha256=gU4-315-QraHa2Eq4Fh3b55QpOM2CkJzh27_Yz13frA,5495
 skrift/templates/setup/restart.html,sha256=GHg31F_e2uLFhWUzJoalk0Y0oYLqsFWyZXWKX3mblbY,1355
 skrift/templates/setup/site.html,sha256=PSOH-q1-ZBl47iSW9-Ad6lEfJn_fzdGD3Pk4vb3xgK4,1680
-skrift-0.1.0a2.dist-info/METADATA,sha256=YhazEDBHS7K8MohN6aRwVbC5VlkbmM3X9vjghL79XR0,6435
-skrift-0.1.0a2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-skrift-0.1.0a2.dist-info/entry_points.txt,sha256=4AIrmbeWKOdZnvTsKT3US6N3X9rrgk9jEDsYOPEZ1AE,74
-skrift-0.1.0a2.dist-info/RECORD,,
+skrift-0.1.0a4.dist-info/METADATA,sha256=4fREc0NuDDDf5aPruF_rmqwPOBzMDsBF12N9lB4CFPw,6435
+skrift-0.1.0a4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+skrift-0.1.0a4.dist-info/entry_points.txt,sha256=4AIrmbeWKOdZnvTsKT3US6N3X9rrgk9jEDsYOPEZ1AE,74
+skrift-0.1.0a4.dist-info/RECORD,,