# Phase 2: Авторизация — Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Frontend-задачи ДОПОЛНИТЕЛЬНО используют superpowers:frontend-design. Steps use checkbox (`- [ ]`) syntax.

**Goal:** Регистрация/логин по email+паролю, cookie-сессии в БД, мультитенантность по пользователям (один проект на пользователя), закрытие IDOR из 1B. Снять зашитый `DEFAULT_PROJECT_ID` во фронте.

**Architecture:** `internal/auth` (argon2id пароли + session store в БД). Auth-эндпоинты `/api/v1/auth/*`. Два middleware: `RequireAuth` (cookie→session→userID в контекст) и `RequireProjectAccess` (pid принадлежит userID, иначе 404). Рефакторинг check/apply/CRUD под `projectID` из контекста + scope `LoadDomainFull`. Фронт: `AuthContext` (текущий user+project из `GET /auth/me`), protected routes, `credentials:'include'`, projectId из контекста вместо зашитого.

**Tech Stack:** Go, `golang.org/x/crypto/argon2`, `crypto/rand`, `crypto/sha256`, `crypto/subtle`, pgx/sqlc, chi; React + TanStack Query + react-router; Vitest.

## Global Constraints

- Module `github.com/vasyakrg/dns-autoresolver`. Фронт в `web/` (npm; sqlc в `~/go/bin` — `export PATH="$(go env GOPATH)/bin:$PATH"`). Store-тесты — Docker (testcontainers).
- **Один проект на пользователя** (создаётся при регистрации). Без шаринга/ролей/switcher.
- Сессия: cookie `session`, `HttpOnly + Secure + SameSite=Lax + Path=/`; в БД — **sha256(token)**, не сам токен. Токен = base64url(`crypto/rand` 32 байта). TTL, например, 720h.
- Пароль: **argon2id** (`m=64MB, t=1, p=4, keyLen=32, salt 16`), формат `$argon2id$v=19$m=65536,t=1,p=4$<b64salt>$<b64hash>`. Verify — `subtle.ConstantTimeCompare`.
- Логин-ошибка — **единый 401** «invalid credentials» (не раскрывать, email или пароль неверны).
- `RequireProjectAccess`: чужой/несуществующий `pid` → **404** (не 403).
- IDOR: `LoadDomainFull` scoped `AND d.project_id=$2`; `service.Check/Apply` и `Loader.LoadDomain` принимают `projectID`; хендлеры берут `pid` из контекста (валидированный middleware).
- Секрет учётки и `password_hash` НИКОГДА не в ответах/логах. Существующие инварианты 1A/1B не регрессировать.
- Каждая задача — зелёные тесты (Go: `go test`; фронт: `npm run test`) и коммит.

---

### Task 1 [Docker]: Миграция sessions/password + store-методы (users/sessions/projects)

**Files:**
- Create: `internal/store/migrations/0003_auth.sql`
- Create: `internal/store/queries/users.sql`, `internal/store/queries/sessions.sql`; Modify: `internal/store/queries/projects.sql` (создать, если нет)
- Regenerate: `internal/store/db/*` (sqlc)
- Modify: `internal/store/tenant.go` (методы-обёртки)
- Create: `internal/store/auth_test.go`

**Interfaces:**
- Produces (методы `*Store`, uuid — google/uuid):
  - `CreateUser(ctx, email, passwordHash string) (User, error)`; `GetUserByEmail(ctx, email string) (User, error)`
  - `CreateProjectForUser(ctx, userID uuid.UUID, name string) (Project, error)`; `GetProjectOwned(ctx, projectID, userID uuid.UUID) (Project, error)`; `GetUserProject(ctx, userID uuid.UUID) (Project, error)`
  - `CreateSession(ctx, userID uuid.UUID, tokenHash string, expiresAt time.Time) error`; `GetSessionUser(ctx, tokenHash string) (uuid.UUID, error)` (только не истёкшие); `DeleteSession(ctx, tokenHash string) error`
  - типы `User{ID, Email string, PasswordHash string}`, `Project{ID, UserID uuid.UUID, Name string}`
  - `RegisterUser(ctx, email, passwordHash string) (User, Project, error)` — транзакция: user + его project

- [ ] **Step 1: Миграция**

`internal/store/migrations/0003_auth.sql`:
```sql
-- +goose Up
ALTER TABLE users ADD COLUMN password_hash text;

CREATE TABLE sessions (
    id         uuid PRIMARY KEY,
    user_id    uuid NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    token_hash text NOT NULL UNIQUE,
    expires_at timestamptz NOT NULL,
    created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX sessions_token_hash_idx ON sessions (token_hash);

-- +goose Down
DROP TABLE sessions;
ALTER TABLE users DROP COLUMN password_hash;
```

- [ ] **Step 2: SQL-запросы**

`internal/store/queries/users.sql`:
```sql
-- name: CreateUser :one
INSERT INTO users (id, email, password_hash) VALUES ($1, $2, $3) RETURNING *;

-- name: GetUserByEmail :one
SELECT * FROM users WHERE email = $1;
```

`internal/store/queries/sessions.sql`:
```sql
-- name: CreateSession :exec
INSERT INTO sessions (id, user_id, token_hash, expires_at) VALUES ($1, $2, $3, $4);

-- name: GetSessionUser :one
SELECT user_id FROM sessions WHERE token_hash = $1 AND expires_at > now();

-- name: DeleteSession :exec
DELETE FROM sessions WHERE token_hash = $1;
```

`internal/store/queries/projects.sql`:
```sql
-- name: CreateProject :one
INSERT INTO projects (id, user_id, name) VALUES ($1, $2, $3) RETURNING *;

-- name: GetProjectOwned :one
SELECT * FROM projects WHERE id = $1 AND user_id = $2;

-- name: GetUserProject :one
SELECT * FROM projects WHERE user_id = $1 ORDER BY created_at LIMIT 1;
```

- [ ] **Step 3: Сгенерировать sqlc**

Run: `export PATH="$(go env GOPATH)/bin:$PATH" && sqlc generate` → `internal/store/db/` обновлён (users.sql.go, sessions.sql.go, projects.sql.go). `go build ./internal/store/db/` компилируется.

- [ ] **Step 4: Store-обёртки**

Добавить в `internal/store/tenant.go` доменные типы и методы (используй `db.Queries`, `uuid.New()`, транзакцию для RegisterUser по образцу `ImportDomains`):
```go
type User struct {
	ID           uuid.UUID
	Email        string
	PasswordHash string
}
type Project struct {
	ID     uuid.UUID
	UserID uuid.UUID
	Name   string
}

func (s *Store) CreateUser(ctx context.Context, email, passwordHash string) (User, error) { /* db.CreateUser */ }
func (s *Store) GetUserByEmail(ctx context.Context, email string) (User, error)           { /* db.GetUserByEmail */ }
func (s *Store) CreateProjectForUser(ctx context.Context, userID uuid.UUID, name string) (Project, error)
func (s *Store) GetProjectOwned(ctx context.Context, projectID, userID uuid.UUID) (Project, error)
func (s *Store) GetUserProject(ctx context.Context, userID uuid.UUID) (Project, error)
func (s *Store) CreateSession(ctx context.Context, userID uuid.UUID, tokenHash string, expiresAt time.Time) error
func (s *Store) GetSessionUser(ctx context.Context, tokenHash string) (uuid.UUID, error)
func (s *Store) DeleteSession(ctx context.Context, tokenHash string) error

// RegisterUser creates a user and their default project in one transaction.
func (s *Store) RegisterUser(ctx context.Context, email, passwordHash string) (User, Project, error) {
	tx, err := s.pool.Begin(ctx)
	if err != nil {
		return User{}, Project{}, err
	}
	defer tx.Rollback(ctx)
	q := s.q.WithTx(tx)
	uid := uuid.New()
	dbu, err := q.CreateUser(ctx, db.CreateUserParams{ID: uid, Email: email, PasswordHash: ptr(passwordHash)})
	if err != nil {
		return User{}, Project{}, err
	}
	dbp, err := q.CreateProject(ctx, db.CreateProjectParams{ID: uuid.New(), UserID: uid, Name: "default"})
	if err != nil {
		return User{}, Project{}, err
	}
	if err := tx.Commit(ctx); err != nil {
		return User{}, Project{}, err
	}
	return toUser(dbu), toProject(dbp), nil
}
```

> Реализатор: `password_hash` — nullable в БД → в сгенерированном типе `*string`/`pgtype.Text`. Хелперы `ptr`/`toUser`/`toProject` сверь с фактическим `models.go`. Пустой хэш никогда не пишется в реальном потоке (регистрация всегда передаёт argon2-хэш).

- [ ] **Step 5: Интеграционные тесты**

`internal/store/auth_test.go` [Docker]: `RegisterUser` создаёт user+project (проект принадлежит user); `GetUserByEmail` находит; `CreateSession`+`GetSessionUser` возвращает userID; истёкшая сессия (`expiresAt` в прошлом) НЕ возвращается; `DeleteSession` удаляет; `GetProjectOwned` чужого userID → ErrNoRows; `GetUserProject` возвращает единственный проект.

- [ ] **Step 6: Проверки и коммит**

Run: `go test ./internal/store/... -v` (Docker) → PASS; `go build ./...`; `go vet ./...`.
```bash
git add internal/store/migrations/0003_auth.sql internal/store/queries/ internal/store/db/ internal/store/tenant.go internal/store/auth_test.go sqlc.yaml
git commit -m "feat(store): миграция sessions/password + методы users/sessions/projects"
```

---

### Task 2: Пакет `internal/auth` (argon2id + сессии)

**Files:**
- Create: `internal/auth/password.go`, `internal/auth/password_test.go`
- Create: `internal/auth/session.go`, `internal/auth/session_test.go`

**Interfaces:**
- Consumes: store (через узкий интерфейс), `golang.org/x/crypto/argon2`
- Produces:
  - `func HashPassword(password string) (string, error)`; `func VerifyPassword(encoded, password string) (bool, error)`
  - `type SessionStore interface { CreateSession(ctx, userID uuid.UUID, tokenHash string, expiresAt time.Time) error; GetSessionUser(ctx, tokenHash string) (uuid.UUID, error); DeleteSession(ctx, tokenHash string) error }`
  - `type Sessions struct { store SessionStore; ttl time.Duration }`; `func NewSessions(store SessionStore, ttl time.Duration) *Sessions`
  - `func (*Sessions) Create(ctx, userID uuid.UUID) (token string, expires time.Time, err error)` — генерит токен, пишет sha256(token)
  - `func (*Sessions) Validate(ctx, token string) (uuid.UUID, error)`; `func (*Sessions) Destroy(ctx, token string) error`
  - `func TokenHash(token string) string` — hex(sha256)

- [ ] **Step 1: argon2id (падающий тест)**

`internal/auth/password_test.go`:
```go
package auth

import "testing"

func TestHashVerifyRoundTrip(t *testing.T) {
	h, err := HashPassword("s3cret-pw")
	if err != nil {
		t.Fatal(err)
	}
	if h == "s3cret-pw" || len(h) < 20 {
		t.Fatalf("bad hash %q", h)
	}
	ok, err := VerifyPassword(h, "s3cret-pw")
	if err != nil || !ok {
		t.Fatalf("verify failed: %v %v", ok, err)
	}
	bad, _ := VerifyPassword(h, "wrong")
	if bad {
		t.Fatal("wrong password must not verify")
	}
}

func TestHashNonDeterministic(t *testing.T) {
	a, _ := HashPassword("same")
	b, _ := HashPassword("same")
	if a == b {
		t.Fatal("salt must randomize hash")
	}
}
```

- [ ] **Step 2: Реализовать password.go**

```go
package auth

import (
	"crypto/rand"
	"crypto/subtle"
	"encoding/base64"
	"fmt"
	"strings"

	"golang.org/x/crypto/argon2"
)

const (
	argonTime    = 1
	argonMemory  = 64 * 1024
	argonThreads = 4
	argonKeyLen  = 32
	argonSaltLen = 16
)

func HashPassword(password string) (string, error) {
	salt := make([]byte, argonSaltLen)
	if _, err := rand.Read(salt); err != nil {
		return "", err
	}
	key := argon2.IDKey([]byte(password), salt, argonTime, argonMemory, argonThreads, argonKeyLen)
	b64 := base64.RawStdEncoding.EncodeToString
	return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
		argonMemory, argonTime, argonThreads, b64(salt), b64(key)), nil
}

func VerifyPassword(encoded, password string) (bool, error) {
	parts := strings.Split(encoded, "$")
	if len(parts) != 6 || parts[1] != "argon2id" {
		return false, fmt.Errorf("auth: bad hash format")
	}
	var m, t uint32
	var p uint8
	if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &m, &t, &p); err != nil {
		return false, err
	}
	salt, err := base64.RawStdEncoding.DecodeString(parts[4])
	if err != nil {
		return false, err
	}
	want, err := base64.RawStdEncoding.DecodeString(parts[5])
	if err != nil {
		return false, err
	}
	got := argon2.IDKey([]byte(password), salt, t, m, p, uint32(len(want)))
	return subtle.ConstantTimeCompare(got, want) == 1, nil
}
```

Run: `go test ./internal/auth/ -run Hash -v` → PASS.

- [ ] **Step 3: Сессии (падающий тест — с мок-store)**

`internal/auth/session_test.go`:
```go
package auth

import (
	"context"
	"testing"
	"time"

	"github.com/google/uuid"
)

type memStore struct {
	byHash map[string]uuid.UUID
	exp    map[string]time.Time
}

func newMem() *memStore { return &memStore{byHash: map[string]uuid.UUID{}, exp: map[string]time.Time{}} }
func (m *memStore) CreateSession(_ context.Context, uid uuid.UUID, h string, e time.Time) error {
	m.byHash[h] = uid
	m.exp[h] = e
	return nil
}
func (m *memStore) GetSessionUser(_ context.Context, h string) (uuid.UUID, error) {
	uid, ok := m.byHash[h]
	if !ok || time.Now().After(m.exp[h]) {
		return uuid.Nil, ErrNoSession
	}
	return uid, nil
}
func (m *memStore) DeleteSession(_ context.Context, h string) error { delete(m.byHash, h); return nil }

func TestSessionCreateValidateDestroy(t *testing.T) {
	s := NewSessions(newMem(), time.Hour)
	uid := uuid.New()
	token, exp, err := s.Create(context.Background(), uid)
	if err != nil || token == "" || exp.Before(time.Now()) {
		t.Fatalf("create: %v %q", err, token)
	}
	got, err := s.Validate(context.Background(), token)
	if err != nil || got != uid {
		t.Fatalf("validate: %v %v", got, err)
	}
	if err := s.Destroy(context.Background(), token); err != nil {
		t.Fatal(err)
	}
	if _, err := s.Validate(context.Background(), token); err == nil {
		t.Fatal("destroyed session must not validate")
	}
}

func TestValidateUnknownToken(t *testing.T) {
	s := NewSessions(newMem(), time.Hour)
	if _, err := s.Validate(context.Background(), "nope"); err == nil {
		t.Fatal("unknown token must error")
	}
}
```

- [ ] **Step 4: Реализовать session.go**

```go
package auth

import (
	"context"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"errors"
	"time"

	"github.com/google/uuid"
)

var ErrNoSession = errors.New("auth: no such session")

type SessionStore interface {
	CreateSession(ctx context.Context, userID uuid.UUID, tokenHash string, expiresAt time.Time) error
	GetSessionUser(ctx context.Context, tokenHash string) (uuid.UUID, error)
	DeleteSession(ctx context.Context, tokenHash string) error
}

type Sessions struct {
	store SessionStore
	ttl   time.Duration
}

func NewSessions(store SessionStore, ttl time.Duration) *Sessions {
	return &Sessions{store: store, ttl: ttl}
}

func TokenHash(token string) string {
	sum := sha256.Sum256([]byte(token))
	return hex.EncodeToString(sum[:])
}

func (s *Sessions) Create(ctx context.Context, userID uuid.UUID) (string, time.Time, error) {
	raw := make([]byte, 32)
	if _, err := rand.Read(raw); err != nil {
		return "", time.Time{}, err
	}
	token := base64.RawURLEncoding.EncodeToString(raw)
	exp := time.Now().Add(s.ttl)
	if err := s.store.CreateSession(ctx, userID, TokenHash(token), exp); err != nil {
		return "", time.Time{}, err
	}
	return token, exp, nil
}

func (s *Sessions) Validate(ctx context.Context, token string) (uuid.UUID, error) {
	return s.store.GetSessionUser(ctx, TokenHash(token))
}

func (s *Sessions) Destroy(ctx context.Context, token string) error {
	return s.store.DeleteSession(ctx, TokenHash(token))
}
```

> Реализатор: `store.GetSessionUser` при отсутствии/истечении должен вернуть ошибку (в Task 1 — `ErrNoRows`); мок в тесте возвращает `ErrNoSession`. Оба трактуются как «нет сессии».

- [ ] **Step 5: Тесты зелёные, коммит**

Run: `go test ./internal/auth/ -v` → PASS. `go get golang.org/x/crypto/argon2` если не подтянут.
```bash
git add internal/auth/ go.mod go.sum
git commit -m "feat(auth): argon2id пароли + session store (sha256 токена)"
```

---

### Task 3: Auth-хендлеры (register/login/logout/me) + cookie

**Files:**
- Create: `internal/api/auth_handlers.go`, `internal/api/auth_test.go`
- Modify: `internal/api/api.go` (интерфейс `AuthService`, поля API, роуты `/api/v1/auth/*`)

**Interfaces:**
- Consumes: `store` (RegisterUser/GetUserByEmail/GetUserProject), `auth.Sessions`, `auth.HashPassword/VerifyPassword`
- Produces:
  - `type AuthStore interface { RegisterUser(ctx, email, passwordHash string) (store.User, store.Project, error); GetUserByEmail(ctx, email string) (store.User, error); GetUserProject(ctx, userID uuid.UUID) (store.Project, error) }`
  - `type SessionManager interface { Create(ctx, userID uuid.UUID) (string, time.Time, error); Validate(ctx, token string) (uuid.UUID, error); Destroy(ctx, token string) error }`
  - хендлеры `handleRegister/handleLogin/handleLogout/handleMe`; DTO `authResponse{ user{id,email}, project{id,name} }` (без password_hash)
  - `func setSessionCookie(w, token string, exp time.Time)`, `func clearSessionCookie(w)`; const `sessionCookieName = "session"`

- [ ] **Step 1: Падающий тест (httptest + мок AuthStore/SessionManager)**

`internal/api/auth_test.go`: 
- `POST /api/v1/auth/register {email,password}` → 200, Set-Cookie `session`, тело `{user,project}` без password. Мок AuthStore.RegisterUser возвращает user+project.
- `POST /login` с верным паролем (мок GetUserByEmail возвращает user с известным argon2-хэшем, `auth.HashPassword("pw")`) → 200 + cookie; с неверным → 401 «invalid credentials».
- `POST /login` несуществующий email → 401 (тот же ответ, не раскрывать).
- `POST /logout` → 200 + cookie очищена (Max-Age<=0), SessionManager.Destroy вызван.
- Ответы НЕ содержат password_hash (grep по телу).

- [ ] **Step 2: Запустить — падает** → FAIL.

- [ ] **Step 3: Реализовать auth_handlers.go**

Ключевое: register — `HashPassword` → `RegisterUser` → `Sessions.Create` → `setSessionCookie` → JSON `{user,project}`. login — `GetUserByEmail` (ошибка → 401), `VerifyPassword` (false → 401), `Sessions.Create` → cookie. logout — прочитать cookie, `Destroy`, `clearSessionCookie`. Cookie:
```go
const sessionCookieName = "session"

func setSessionCookie(w http.ResponseWriter, token string, exp time.Time) {
	http.SetCookie(w, &http.Cookie{
		Name: sessionCookieName, Value: token, Path: "/",
		HttpOnly: true, Secure: true, SameSite: http.SameSiteLaxMode, Expires: exp,
	})
}
func clearSessionCookie(w http.ResponseWriter) {
	http.SetCookie(w, &http.Cookie{
		Name: sessionCookieName, Value: "", Path: "/",
		HttpOnly: true, Secure: true, SameSite: http.SameSiteLaxMode, MaxAge: -1,
	})
}
```
`handleMe` — из контекста `userID` (положит middleware в Task 4) → `GetUserProject` → `{user,project}`. Register/login публичны; me/logout — под `RequireAuth` (подключить в Task 4 или сразу, если middleware готов).

Обновить `api.go`: `API` получает поля `Auth AuthStore`, `Sessions SessionManager`; роуты:
```go
r.Route("/api/v1/auth", func(r chi.Router) {
	r.Post("/register", a.handleRegister)
	r.Post("/login", a.handleLogin)
	r.Post("/logout", a.handleLogout)   // защитится RequireAuth в Task 4
	r.Get("/me", a.handleMe)            // защитится RequireAuth в Task 4
})
```

- [ ] **Step 4: Тесты зелёные, коммит**

Run: `go test ./internal/api/ -run Auth -v` → PASS. `go build ./...`; `go vet ./...`.
```bash
git add internal/api/auth_handlers.go internal/api/auth_test.go internal/api/api.go
git commit -m "feat(api): auth-хендлеры register/login/logout/me + session cookie"
```

---

### Task 4: Middleware (RequireAuth + RequireProjectAccess) + IDOR-рефакторинг

**Files:**
- Create: `internal/api/middleware.go`, `internal/api/middleware_test.go`
- Modify: `internal/store/queries/domains.sql` (`LoadDomainFull` scope), regen sqlc; `internal/store/loader.go`
- Modify: `internal/service/service.go` (Check/Apply/Loader принимают projectID)
- Modify: `internal/api/api.go` (подключить middleware; хендлеры check/apply берут pid из контекста), `internal/api/handlers.go`, `internal/api/tenant_handlers.go`
- Modify: `cmd/server/main.go` (собрать auth+sessions+middleware)

**Interfaces:**
- Produces:
  - `func (a *API) RequireAuth(next http.Handler) http.Handler` — cookie→`Sessions.Validate`→`userID` в контекст; иначе 401
  - `func (a *API) RequireProjectAccess(next http.Handler) http.Handler` — `pid` из URLParam→`GetProjectOwned(pid, userID)`→404 если не найден; кладёт `projectID` в контекст
  - контекст-хелперы `userIDFrom(ctx)`, `projectIDFrom(ctx)`
- Изменяет: `service.Check(ctx, projectID, domainID)`, `Apply(ctx, projectID, domainID, req)`; `Loader.LoadDomain(ctx, projectID, domainID)`; `CheckApplier` — те же сигнатуры; `LoadDomainFull` — `WHERE d.id=$1 AND d.project_id=$2`.

- [ ] **Step 1: Падающие тесты middleware + IDOR**

`internal/api/middleware_test.go`:
- `RequireAuth`: нет cookie → 401; битый токен (Validate ошибка) → 401; валидный → next вызван, `userIDFrom` установлен.
- `RequireProjectAccess`: `GetProjectOwned` возвращает ошибку (чужой проект) → 404; успех → next, `projectIDFrom` установлен.
- **IDOR-регресс** (в auth_test или отдельном): запрос `GET /api/v1/projects/{pidB}/domains/{did}/check` от пользователя A (сессия A, project A), где pidB — проект B → 404, `service.Check` НЕ вызван.

- [ ] **Step 2: Запустить — падает** → FAIL.

- [ ] **Step 3: Реализовать middleware.go**

```go
package api

import (
	"context"
	"net/http"

	"github.com/go-chi/chi/v5"
	"github.com/google/uuid"
)

type ctxKey string

const (
	ctxUserID    ctxKey = "userID"
	ctxProjectID ctxKey = "projectID"
)

func (a *API) RequireAuth(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		c, err := r.Cookie(sessionCookieName)
		if err != nil {
			writeErr(w, http.StatusUnauthorized, "unauthorized")
			return
		}
		uid, err := a.Sessions.Validate(r.Context(), c.Value)
		if err != nil {
			writeErr(w, http.StatusUnauthorized, "unauthorized")
			return
		}
		ctx := context.WithValue(r.Context(), ctxUserID, uid)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

func (a *API) RequireProjectAccess(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		uid, ok := userIDFrom(r.Context())
		if !ok {
			writeErr(w, http.StatusUnauthorized, "unauthorized")
			return
		}
		pid, err := uuid.Parse(chi.URLParam(r, "pid"))
		if err != nil {
			writeErr(w, http.StatusBadRequest, "invalid project id")
			return
		}
		if _, err := a.Auth.GetProjectOwned(r.Context(), pid, uid); err != nil {
			writeErr(w, http.StatusNotFound, "not found")
			return
		}
		ctx := context.WithValue(r.Context(), ctxProjectID, pid)
		next.ServeHTTP(w, r.WithContext(ctx))
	})
}

func userIDFrom(ctx context.Context) (uuid.UUID, bool) {
	v, ok := ctx.Value(ctxUserID).(uuid.UUID)
	return v, ok
}
func projectIDFrom(ctx context.Context) (uuid.UUID, bool) {
	v, ok := ctx.Value(ctxProjectID).(uuid.UUID)
	return v, ok
}
```

(`API.Auth` расширить методом `GetProjectOwned(ctx, projectID, userID uuid.UUID) (store.Project, error)` в интерфейсе AuthStore.)

- [ ] **Step 4: Подключить middleware в роутере**

`api.go`: обернуть `/api/v1/projects/{pid}` в `RequireAuth` + `RequireProjectAccess`; `/auth/me`, `/auth/logout` — в `RequireAuth`:
```go
r.Route("/api/v1/auth", func(r chi.Router) {
	r.Post("/register", a.handleRegister)
	r.Post("/login", a.handleLogin)
	r.Group(func(r chi.Router) {
		r.Use(a.RequireAuth)
		r.Post("/logout", a.handleLogout)
		r.Get("/me", a.handleMe)
	})
})
r.Route("/api/v1/projects/{pid}", func(r chi.Router) {
	r.Use(a.RequireAuth)
	r.Use(a.RequireProjectAccess)
	// ... существующие domains/accounts/templates
})
```

- [ ] **Step 5: IDOR-рефакторинг check/apply**

- `LoadDomainFull` в `domains.sql`: `WHERE d.id = $1 AND d.project_id = $2`; regen sqlc.
- `internal/store/loader.go`: `LoadDomain(ctx, projectID, domainID uuid.UUID)` → `db.LoadDomainFullParams{ID: domainID, ProjectID: projectID}`.
- `internal/service/service.go`: `Loader.LoadDomain(ctx, projectID, domainID)`; `resolve(ctx, projectID, domainID)`; `Check(ctx, projectID, domainID)`; `Apply(ctx, projectID, domainID, req)`; `SaveCheckRun` без изменений.
- `internal/api/api.go` `CheckApplier`: `Check(ctx, projectID, domainID uuid.UUID)`, `Apply(ctx, projectID, domainID uuid.UUID, req service.ApplyRequest)`.
- `handlers.go` `handleCheck/handleApply`: `pid := projectIDFrom(r.Context())` (гарантирован middleware), `did := uuid.Parse(URLParam "did")` → `a.Svc.Check(ctx, pid, did)`.
- `tenant_handlers.go` CRUD: заменить приём `pid` из URL на `projectIDFrom(ctx)` (middleware уже провалидировал владение). Существующая scoped-логика store сохраняется.
- Обновить моки в существующих api-тестах под новые сигнатуры (CheckApplier.Check/Apply c projectID); установить `projectID` в контексте запроса в тестах (обернуть в RequireProjectAccess-мок или прямой `context.WithValue`).

- [ ] **Step 6: Wiring cmd/server**

`main.go`: создать `sessions := auth.NewSessions(store, 720*time.Hour)`; `api.API{ Svc: svc, Store: store (TenantStore), Cipher: cipher, Reg: reg, Auth: store, Sessions: sessions }`. (Store реализует AuthStore напрямую — методы из Task 1.)

- [ ] **Step 7: Проверки, коммит**

Run: `go test ./... -v` (Docker) → все зелёные, включая IDOR-регресс. `go build ./...`; `go vet ./...`.
```bash
git add internal/api/ internal/service/ internal/store/ cmd/server/main.go
git commit -m "feat(api): RequireAuth+RequireProjectAccess middleware, IDOR-scope check/apply по projectID"
```

---

### Task 5: Frontend — AuthContext + API-клиент под сессии

**Files:**
- Modify: `web/src/api/client.ts`, `web/src/api/types.ts`, `web/src/lib/config.ts` (убрать зашитый DEFAULT_PROJECT_ID), `web/src/hooks/useApi.ts`
- Create: `web/src/auth/AuthContext.tsx`, `web/src/auth/AuthContext.test.tsx`
- Modify: `web/src/api/client.test.ts`

**Interfaces:**
- Produces:
  - типы `User{id,email}`, `Project{id,name}`, `AuthState{user,project}`
  - `api.auth`: `register(email,password)`, `login(email,password)`, `logout()`, `me()` → `AuthState`
  - клиент ресурсов принимает `projectId` (первым аргументом) вместо зашитого; `req` использует `credentials:"include"` и при 401 бросает типизированную `UnauthorizedError`
  - `AuthProvider` + `useAuth()` → `{user, project, loading, login, register, logout}`
  - хуки в `useApi.ts` читают `project.id` из `useAuth()` и передают в client

- [ ] **Step 1: Падающие тесты клиента (credentials, projectId, 401)**

`client.test.ts`: `api.auth.login` шлёт POST `/api/v1/auth/login` с `credentials:"include"`; ресурс-метод `api.listDomains(projectId)` бьёт `/api/v1/projects/${projectId}/domains`; 401 → `UnauthorizedError`. Реальные ассерты на fetch mock.

- [ ] **Step 2: Реализовать клиент**

`config.ts`: удалить `DEFAULT_PROJECT_ID`/`API_BASE`; `const API_ROOT = "/api/v1"`.
`client.ts`: `req` добавляет `credentials:"include"`; при `res.status===401` бросает `new UnauthorizedError()`. `api.auth = { register, login, logout, me }` на `${API_ROOT}/auth/*`. Ресурс-методы: `listDomains(projectId)` → `${API_ROOT}/projects/${projectId}/domains`, и т.д. (projectId первым аргументом во всех ресурс-методах).

- [ ] **Step 3: AuthContext**

`AuthContext.tsx`: `AuthProvider` — при монтировании `api.auth.me()` (401 → неавторизован, не ошибка); хранит `{user, project, loading}`; методы `login/register` (успех → set state), `logout` (→ clear state). `useAuth()` хук. `UnauthorizedError` из client → состояние «не авторизован».

`AuthContext.test.tsx`: мок `api.auth.me` (успех → user/project в контексте; 401 → неавторизован); `login` устанавливает user; `logout` очищает.

- [ ] **Step 4: Хуки под projectId из контекста**

`useApi.ts`: каждый ресурс-хук берёт `const { project } = useAuth()` и передаёт `project.id` в client + включает в queryKey (`["domains", project?.id]`); `enabled: !!project`. Мутации аналогично.

- [ ] **Step 5: Тесты зелёные, коммит**

Run: `cd web && npm run test -- client AuthContext` → PASS; `npx tsc --noEmit`; `npm run test` (адаптировать сломанные тесты страниц под новую сигнатуру, если падают — но страницы правятся в Task 6; здесь минимально чините типы).
```bash
git add web/src/api web/src/lib web/src/hooks web/src/auth
git commit -m "feat(web): AuthContext + клиент под cookie-сессии, projectId из контекста"
```

- [ ] **Step 6: Commit** (см. выше)

---

### Task 6: Frontend — Login/Register + protected routes + logout

**Files:**
- Create: `web/src/pages/LoginPage.tsx`, `web/src/pages/RegisterPage.tsx`, `web/src/pages/LoginPage.test.tsx`
- Create: `web/src/auth/ProtectedRoute.tsx`, `web/src/auth/ProtectedRoute.test.tsx`
- Modify: `web/src/App.tsx` (роуты /login /register + protected), `web/src/main.tsx` (AuthProvider), `web/src/components/Layout.tsx` (logout + email)

**Interfaces:**
- Consumes: `useAuth`
- Produces: `LoginPage`, `RegisterPage`, `ProtectedRoute` (обёртка: неавторизован → `<Navigate to="/login">`)

**Дизайн:** используй skill frontend-design (тёмная «technical console», консистентно с существующим UI).

- [ ] **Step 1: Падающий тест ProtectedRoute + Login**

`ProtectedRoute.test.tsx`: неавторизован (useAuth loading=false, user=null) → редирект на /login; авторизован → рендер children. `LoginPage.test.tsx`: ввод email+пароль → submit вызывает `useAuth().login`; ошибка входа показывается (role=alert).

- [ ] **Step 2: Реализовать**

- `ProtectedRoute.tsx`: `const {user, loading} = useAuth(); if (loading) return spinner; if (!user) return <Navigate to="/login" replace/>; return children`.
- `LoginPage.tsx`/`RegisterPage.tsx`: форма (email, пароль) через field + react-hook-form/zod; submit → `login`/`register`; при успехе → `/domains` (Navigate); ошибка → `role=alert`. Ссылки между login↔register.
- `main.tsx`: обернуть в `<AuthProvider>`.
- `App.tsx`: роуты `/login`, `/register` (публичные, авторизованный → редирект `/domains`); всё остальное — в `<ProtectedRoute>`.
- `Layout.tsx`: показать email пользователя + кнопка Logout (`useAuth().logout` → `/login`).
- Глобально: при `UnauthorizedError` от любого запроса — AuthContext сбрасывает user (→ ProtectedRoute уводит на /login). Реализовать через QueryClient onError или в useAuth.

- [ ] **Step 3: Тесты зелёные, сборка, коммит**

Run: `cd web && npm run test` (все, включая обновлённые page-тесты под projectId) → PASS; `npx tsc --noEmit`; `npm run build`.
```bash
git add web/src/pages web/src/auth web/src/App.tsx web/src/main.tsx web/src/components/Layout.tsx
git commit -m "feat(web): Login/Register страницы, protected routes, logout"
```

---

## Self-Review

- **Spec coverage:** миграция sessions/password + store (T1), argon2id+сессии (T2), auth-хендлеры+cookie (T3), middleware RequireAuth/RequireProjectAccess + IDOR-scope (T4), фронт AuthContext+клиент под сессии (T5), Login/Register+protected+logout (T6). Все пункты spec-секции Фазы 2 покрыты. Один проект на пользователя (RegisterUser транзакцией). IDOR закрыт middleware + scope LoadDomainFull.
- **Type consistency:** `store.User/Project` едины (T1→T3→T4); `auth.Sessions` (Create/Validate/Destroy) едины (T2→T3→T4); `SessionManager`/`AuthStore` интерфейсы api (T3→T4); фронт `AuthState/User/Project`, `api.auth.*`, ресурс-методы с `projectId` (T5→T6); cookie `session` HttpOnly+Secure+SameSite=Lax (T3).
- **Placeholders:** нет кода-плейсхолдера. Пометки «реализатор» — точки сверки с sqlc-генерацией (nullable password_hash) и адаптации существующих тестов/страниц под новые сигнатуры; образцы кода приведены.

## Проверка (end-to-end)

1. `go test ./... -v` (Docker) — все Go-пакеты зелёные, включая IDOR-регресс (A не видит проект B → 404).
2. `cd web && npm run test && npx tsc --noEmit && npm run build` — фронт зелёный.
3. `make web && go run ./cmd/server` (Postgres + env): открыть `/` → редирект `/login`; зарегистрироваться → создаётся user+project, редирект на `/domains`; выйти → `/login`; войти снова; проверить, что запрос к чужому `pid` (подмена в URL) → 404; secret учётки и password_hash не появляются в ответах.