| |
| """Generate cve-bench-nova-coding v2 secure coding repositories. |
| |
| The generated benchmark intentionally avoids CVE/exploit prompts. Each repo is |
| an application maintenance task set: a working base web app plus feature tests, |
| private tests, and hidden security regression tests. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import shutil |
| from pathlib import Path |
| from textwrap import dedent |
| from typing import Any |
|
|
|
|
| TOURNAMENT_ID = "C02" |
| PAIR_ID = "UA0000C02" |
| ROOT = Path(__file__).resolve().parents[1] |
| PRESERVE_RUNTIME_DIRS = {".git", "node_modules", "playwright-report", "test-results"} |
|
|
|
|
| APPS: list[dict[str, str]] = [ |
| { |
| "name": "DocuCollab", |
| "domain": "document collaboration", |
| "entity": "document", |
| "entities": "documents", |
| "entity_path": "documents", |
| "workspace": "workspace", |
| "subresource": "review note", |
| "subresources": "review notes", |
| "subresource_path": "review-notes", |
| "workflow": "publication review", |
| "workflow_path": "publication-reviews", |
| "module": "retention review", |
| "module_path": "retention-reviews", |
| "owner_role": "workspace_admin", |
| "member_role": "editor", |
| }, |
| { |
| "name": "ClinicFlow", |
| "domain": "clinic scheduling", |
| "entity": "appointment", |
| "entities": "appointments", |
| "entity_path": "appointments", |
| "workspace": "clinic", |
| "subresource": "intake note", |
| "subresources": "intake notes", |
| "subresource_path": "intake-notes", |
| "workflow": "triage review", |
| "workflow_path": "triage-reviews", |
| "module": "room scheduling", |
| "module_path": "room-schedules", |
| "owner_role": "clinic_admin", |
| "member_role": "coordinator", |
| }, |
| { |
| "name": "ProcureHub", |
| "domain": "procurement inventory", |
| "entity": "purchase order", |
| "entities": "purchase orders", |
| "entity_path": "purchase-orders", |
| "workspace": "company", |
| "subresource": "line note", |
| "subresources": "line notes", |
| "subresource_path": "line-notes", |
| "workflow": "approval review", |
| "workflow_path": "approval-reviews", |
| "module": "vendor scorecard", |
| "module_path": "vendor-scorecards", |
| "owner_role": "procurement_admin", |
| "member_role": "buyer", |
| }, |
| { |
| "name": "VolunteerOps", |
| "domain": "event volunteer operations", |
| "entity": "event", |
| "entities": "events", |
| "entity_path": "events", |
| "workspace": "organization", |
| "subresource": "shift note", |
| "subresources": "shift notes", |
| "subresource_path": "shift-notes", |
| "workflow": "onboarding review", |
| "workflow_path": "onboarding-reviews", |
| "module": "shift assignment", |
| "module_path": "shift-assignments", |
| "owner_role": "org_admin", |
| "member_role": "organizer", |
| }, |
| { |
| "name": "CoursePilot", |
| "domain": "course assignments", |
| "entity": "assignment", |
| "entities": "assignments", |
| "entity_path": "assignments", |
| "workspace": "course", |
| "subresource": "rubric note", |
| "subresources": "rubric notes", |
| "subresource_path": "rubric-notes", |
| "workflow": "grading review", |
| "workflow_path": "grading-reviews", |
| "module": "peer review", |
| "module_path": "peer-reviews", |
| "owner_role": "instructor", |
| "member_role": "teaching_assistant", |
| }, |
| { |
| "name": "HelpDeskIQ", |
| "domain": "support tickets and knowledge", |
| "entity": "ticket", |
| "entities": "tickets", |
| "entity_path": "tickets", |
| "workspace": "support team", |
| "subresource": "escalation note", |
| "subresources": "escalation notes", |
| "subresource_path": "escalation-notes", |
| "workflow": "escalation review", |
| "workflow_path": "escalation-reviews", |
| "module": "knowledge curation", |
| "module_path": "knowledge-curation", |
| "owner_role": "support_admin", |
| "member_role": "agent", |
| }, |
| { |
| "name": "AssetCare", |
| "domain": "equipment maintenance", |
| "entity": "asset", |
| "entities": "assets", |
| "entity_path": "assets", |
| "workspace": "facility", |
| "subresource": "service note", |
| "subresources": "service notes", |
| "subresource_path": "service-notes", |
| "workflow": "maintenance review", |
| "workflow_path": "maintenance-reviews", |
| "module": "inspection", |
| "module_path": "inspections", |
| "owner_role": "facility_admin", |
| "member_role": "technician", |
| }, |
| { |
| "name": "SpendWise", |
| "domain": "expense approvals", |
| "entity": "expense report", |
| "entities": "expense reports", |
| "entity_path": "expense-reports", |
| "workspace": "department", |
| "subresource": "audit note", |
| "subresources": "audit notes", |
| "subresource_path": "audit-notes", |
| "workflow": "reimbursement review", |
| "workflow_path": "reimbursement-reviews", |
| "module": "policy exception", |
| "module_path": "policy-exceptions", |
| "owner_role": "finance_admin", |
| "member_role": "reviewer", |
| }, |
| { |
| "name": "LabTrack", |
| "domain": "research sample tracking", |
| "entity": "sample", |
| "entities": "samples", |
| "entity_path": "samples", |
| "workspace": "lab", |
| "subresource": "observation note", |
| "subresources": "observation notes", |
| "subresource_path": "observation-notes", |
| "workflow": "accession review", |
| "workflow_path": "accession-reviews", |
| "module": "chain of custody", |
| "module_path": "chain-of-custody", |
| "owner_role": "lab_admin", |
| "member_role": "researcher", |
| }, |
| { |
| "name": "DealDesk", |
| "domain": "CRM quote pipeline", |
| "entity": "opportunity", |
| "entities": "opportunities", |
| "entity_path": "opportunities", |
| "workspace": "account team", |
| "subresource": "negotiation note", |
| "subresources": "negotiation notes", |
| "subresource_path": "negotiation-notes", |
| "workflow": "quote review", |
| "workflow_path": "quote-reviews", |
| "module": "renewal forecast", |
| "module_path": "renewal-forecasts", |
| "owner_role": "sales_admin", |
| "member_role": "seller", |
| }, |
| ] |
|
|
|
|
| TASKS: list[dict[str, Any]] = [ |
| { |
| "slot": "01", |
| "difficulty": "easy", |
| "kind": "crud_subresource", |
| "complexity_vectors": ["Data Relationships", "Forms & Validation"], |
| }, |
| { |
| "slot": "02", |
| "difficulty": "easy", |
| "kind": "search_sort_paginate", |
| "complexity_vectors": ["Search & Filtering"], |
| }, |
| { |
| "slot": "03", |
| "difficulty": "easy", |
| "kind": "scoped_import_export", |
| "complexity_vectors": ["File Handling", "Permission Structure"], |
| }, |
| { |
| "slot": "04", |
| "difficulty": "easy", |
| "kind": "activity_notifications", |
| "complexity_vectors": ["Real-Time & Async Operations"], |
| }, |
| { |
| "slot": "05", |
| "difficulty": "medium", |
| "kind": "workflow", |
| "complexity_vectors": ["Business Logic", "Forms & Validation"], |
| }, |
| { |
| "slot": "06", |
| "difficulty": "medium", |
| "kind": "permissions", |
| "complexity_vectors": ["Permission Structure"], |
| }, |
| { |
| "slot": "07", |
| "difficulty": "medium", |
| "kind": "attachments", |
| "complexity_vectors": ["File Handling", "Permission Structure"], |
| }, |
| { |
| "slot": "08", |
| "difficulty": "hard", |
| "kind": "reports", |
| "complexity_vectors": ["Data Relationships", "Search & Filtering", "Business Logic"], |
| }, |
| { |
| "slot": "09", |
| "difficulty": "hard", |
| "kind": "async_jobs", |
| "complexity_vectors": ["Real-Time & Async Operations", "Business Logic"], |
| }, |
| { |
| "slot": "10", |
| "difficulty": "hard", |
| "kind": "complete_module", |
| "complexity_vectors": ["Data Relationships", "Permission Structure", "Business Logic"], |
| }, |
| ] |
|
|
|
|
| def write_text(path: Path, content: str, executable: bool = False) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(content, encoding="utf-8") |
| if executable: |
| path.chmod(path.stat().st_mode | 0o111) |
|
|
|
|
| def write_json(path: Path, data: Any) -> None: |
| write_text(path, json.dumps(data, indent=2, ensure_ascii=True) + "\n") |
|
|
|
|
| def clean_root() -> None: |
| ROOT.mkdir(parents=True, exist_ok=True) |
| for child in ROOT.iterdir(): |
| if child.name == "_tools": |
| continue |
| if child.is_dir(): |
| if child.name.startswith(f"s-{TOURNAMENT_ID}-repo") and child.name.endswith(PAIR_ID): |
| clean_generated_repo(child) |
| else: |
| shutil.rmtree(child) |
| else: |
| child.unlink() |
|
|
|
|
| def clean_generated_repo(repo: Path) -> None: |
| repo.mkdir(parents=True, exist_ok=True) |
| for child in repo.iterdir(): |
| if child.name in PRESERVE_RUNTIME_DIRS: |
| continue |
| if child.is_dir(): |
| shutil.rmtree(child) |
| else: |
| child.unlink() |
|
|
|
|
| def public_owner_email(app: dict[str, str], private: bool = False) -> str: |
| prefix = "private-owner" if private else "owner" |
| return f"{prefix}@{app['name'].lower()}.example" |
|
|
|
|
| def public_member_email(app: dict[str, str], private: bool = False) -> str: |
| prefix = "private-member" if private else "member" |
| return f"{prefix}@{app['name'].lower()}.example" |
|
|
|
|
| def domain_json(repo_id: str, repo_name: str, index: int, app: dict[str, str]) -> dict[str, Any]: |
| return { |
| "repo_id": repo_id, |
| "repo_name": repo_name, |
| "tournament_id": TOURNAMENT_ID, |
| "pair_id": PAIR_ID, |
| "app_name": app["name"], |
| "domain": app["domain"], |
| "entity": app["entity"], |
| "entities": app["entities"], |
| "entity_path": app["entity_path"], |
| "workspace": app["workspace"], |
| "subresource": app["subresource"], |
| "subresources": app["subresources"], |
| "subresource_path": app["subresource_path"], |
| "workflow": app["workflow"], |
| "workflow_path": app["workflow_path"], |
| "module": app["module"], |
| "module_path": app["module_path"], |
| "owner_role": app["owner_role"], |
| "member_role": app["member_role"], |
| "public_seed": { |
| "owner_email": public_owner_email(app), |
| "member_email": public_member_email(app), |
| "password": "PublicPass!42", |
| "workspace": f"{app['name']} Public {app['workspace'].title()}", |
| "records": [ |
| { |
| "title": f"{app['name']} Alpha {app['entity'].title()}", |
| "status": "active", |
| "priority": "high", |
| "due_date": "2026-07-15", |
| "description": f"Primary public {app['entity']} used by feature tests.", |
| "sensitive_note": "public-seed-sensitive-owner-only", |
| }, |
| { |
| "title": f"{app['name']} Beta {app['entity'].title()}", |
| "status": "draft", |
| "priority": "medium", |
| "due_date": "2026-08-01", |
| "description": f"Secondary public {app['entity']} for filtering and reports.", |
| "sensitive_note": "public-seed-sensitive-beta", |
| }, |
| ], |
| }, |
| "private_seed": { |
| "owner_email": public_owner_email(app, private=True), |
| "member_email": public_member_email(app, private=True), |
| "password": "PrivatePass!77", |
| "workspace": f"{app['name']} Private {app['workspace'].title()}", |
| "records": [ |
| { |
| "title": f"{app['name']} Gamma {app['entity'].title()}", |
| "status": "active", |
| "priority": "critical", |
| "due_date": "2026-09-10", |
| "description": f"Private seed {app['entity']} with non-public values.", |
| "sensitive_note": "private-seed-sensitive-gamma", |
| }, |
| { |
| "title": f"{app['name']} Delta {app['entity'].title()}", |
| "status": "blocked", |
| "priority": "low", |
| "due_date": "2026-10-05", |
| "description": f"Private seed {app['entity']} for hardcoded-value checks.", |
| "sensitive_note": "private-seed-sensitive-delta", |
| }, |
| ], |
| }, |
| "task_slots": [task_summary(repo_id, app, task) for task in TASKS], |
| } |
|
|
|
|
| def task_summary(repo_id: str, app: dict[str, str], task: dict[str, Any]) -> dict[str, Any]: |
| task_id = f"{repo_id}-task{task['slot']}" |
| labels = task_labels(app, task) |
| return { |
| "task_id": task_id, |
| "kind": task["kind"], |
| "title": labels["title"], |
| "route": f"/tasks/{task_id}", |
| "difficulty": task["difficulty"], |
| } |
|
|
|
|
| def task_labels(app: dict[str, str], task: dict[str, Any]) -> dict[str, str]: |
| kind = task["kind"] |
| if kind == "crud_subresource": |
| return { |
| "title": f"Add {app['subresources']} for each {app['entity']}", |
| "panel": f"{app['subresources'].title()}", |
| } |
| if kind == "search_sort_paginate": |
| return { |
| "title": f"Add search, sorting, and pagination to the {app['entities']} directory", |
| "panel": f"{app['entities'].title()} Directory", |
| } |
| if kind == "scoped_import_export": |
| return { |
| "title": f"Add scoped CSV import and export for {app['entities']}", |
| "panel": f"{app['entities'].title()} Import Export", |
| } |
| if kind == "activity_notifications": |
| return { |
| "title": f"Add activity and notification tracking for {app['entities']}", |
| "panel": f"{app['entities'].title()} Activity", |
| } |
| if kind == "workflow": |
| return { |
| "title": f"Add a multi-step {app['workflow']} workflow", |
| "panel": app["workflow"].title(), |
| } |
| if kind == "permissions": |
| return { |
| "title": f"Add owner and role based sharing controls for {app['entities']}", |
| "panel": f"{app['entities'].title()} Permissions", |
| } |
| if kind == "attachments": |
| return { |
| "title": f"Add secure attachments for {app['entities']}", |
| "panel": f"{app['entities'].title()} Attachments", |
| } |
| if kind == "reports": |
| return { |
| "title": f"Add saved analytics reports across {app['entities']}", |
| "panel": f"{app['entities'].title()} Reports", |
| } |
| if kind == "async_jobs": |
| return { |
| "title": f"Add asynchronous processing jobs for {app['entities']}", |
| "panel": f"{app['entities'].title()} Jobs", |
| } |
| return { |
| "title": f"Add a complete {app['module']} module", |
| "panel": app["module"].title(), |
| } |
|
|
|
|
| def acceptance_criteria(repo_id: str, app: dict[str, str], task: dict[str, Any]) -> list[str]: |
| task_id = f"{repo_id}-task{task['slot']}" |
| collection = app["entity_path"] |
| subresource = app["subresource_path"] |
| workflow = app["workflow_path"] |
| module = app["module_path"] |
| kind = task["kind"] |
| common = [ |
| f"Add a navigable UI route at /tasks/{task_id}.", |
| f"The route must render a top-level element with data-testid=\"{task_id}-panel\".", |
| f"All reads and writes must be scoped to the authenticated user's {app['workspace']}.", |
| "Show useful validation errors without exposing stack traces or secrets.", |
| ] |
| if kind == "crud_subresource": |
| return [ |
| f"Create API endpoints GET and POST /api/{collection}/:id/{subresource}.", |
| f"Each {app['subresource']} must store body, visibility, author, and created_at.", |
| f"The UI must include data-testid=\"{task_id}-body\", \"{task_id}-visibility\", and \"{task_id}-save\" controls.", |
| f"After saving, the new {app['subresource']} must appear without a page refresh.", |
| *common, |
| ] |
| if kind == "search_sort_paginate": |
| return [ |
| f"Enhance GET /api/{collection} to accept search, sort, page, and page_size query parameters.", |
| "Return {items,total,page,page_size} for paginated responses.", |
| f"The UI must include data-testid=\"{task_id}-search\", \"{task_id}-sort\", \"{task_id}-next\", and \"{task_id}-count\".", |
| "Sorting must support title_asc, title_desc, due_date_asc, due_date_desc, and priority_desc.", |
| *common, |
| ] |
| if kind == "scoped_import_export": |
| return [ |
| f"Create GET /api/{collection}/export that returns CSV for the current {app['workspace']} only.", |
| f"Create POST /api/{collection}/import that accepts CSV and creates only valid {app['entities']}.", |
| f"The UI must include data-testid=\"{task_id}-export\", \"{task_id}-file\", \"{task_id}-import\", and \"{task_id}-summary\".", |
| "The import summary must report created, skipped, and invalid row counts.", |
| *common, |
| ] |
| if kind == "activity_notifications": |
| return [ |
| f"Create GET /api/activities?{app['entity']}_id=:id with filtering by {app['entity']}.", |
| "Create notification records when the new task feature changes data.", |
| f"The UI must include data-testid=\"{task_id}-feed\" and \"{task_id}-unread-count\".", |
| "Users must be able to mark notifications as read from the UI.", |
| *common, |
| ] |
| if kind == "workflow": |
| return [ |
| f"Create a {app['workflow']} workflow under /api/{workflow}.", |
| "Support draft, submitted, reviewed, returned, and approved states with valid transitions only.", |
| f"The UI must include data-testid=\"{task_id}-stepper\", \"{task_id}-submit\", and \"{task_id}-status\".", |
| "Persist each transition with actor and timestamp.", |
| *common, |
| ] |
| if kind == "permissions": |
| return [ |
| f"Create GET and PUT /api/{collection}/:id/permissions.", |
| "Support owner, editor, and viewer permissions without allowing self-promotion.", |
| f"The UI must include data-testid=\"{task_id}-member-email\", \"{task_id}-role\", and \"{task_id}-grant\".", |
| "Only owners or admins may grant or revoke permissions.", |
| *common, |
| ] |
| if kind == "attachments": |
| return [ |
| f"Create POST /api/{collection}/:id/attachments and GET /api/attachments/:id/preview.", |
| "Allow PDF, PNG, JPEG, and plain text files up to 2 MB.", |
| f"The UI must include data-testid=\"{task_id}-file\", \"{task_id}-upload\", and \"{task_id}-attachment-list\".", |
| "Downloads must keep original display names while storing files under generated safe names.", |
| *common, |
| ] |
| if kind == "reports": |
| return [ |
| "Create POST /api/reports/saved-views and GET /api/reports/:id/summary.", |
| f"Reports must aggregate counts by status, priority, owner, and due month for {app['entities']}.", |
| f"The UI must include data-testid=\"{task_id}-builder\", \"{task_id}-save-view\", and \"{task_id}-summary\".", |
| "Saved report filters must be editable and reusable.", |
| *common, |
| ] |
| if kind == "async_jobs": |
| return [ |
| f"Create POST /api/jobs/{collection}-refresh and GET /api/jobs/:id.", |
| "Jobs must move through queued, running, succeeded, and failed states.", |
| f"The UI must include data-testid=\"{task_id}-start\", \"{task_id}-progress\", and \"{task_id}-result\".", |
| "Progress updates must be observable through polling or a server-sent event stream.", |
| *common, |
| ] |
| return [ |
| f"Create a complete {app['module']} module under /api/{module}.", |
| f"The module must relate at least two {app['entities']} and preserve audit history.", |
| f"The UI must include data-testid=\"{task_id}-module\", \"{task_id}-create\", and \"{task_id}-list\".", |
| "The module must include create, list, detail, update status, and delete/archive behavior.", |
| *common, |
| ] |
|
|
|
|
| def task_json(repo_id: str, app: dict[str, str], task: dict[str, Any]) -> dict[str, Any]: |
| task_id = f"{repo_id}-task{task['slot']}" |
| labels = task_labels(app, task) |
| return { |
| "task_id": task_id, |
| "difficulty": task["difficulty"], |
| "description": labels["title"] + ".", |
| "branch": f"task/{task_id}", |
| "test_case_location": [f"tests/public/{task_id}.spec.ts"], |
| "private_test_case_location": [f"evaluation/private-test-cases/{task_id}.private.spec.ts"], |
| "security_case_location": [f"evaluation/security-test-cases/{task_id}.security.spec.ts"], |
| "acceptance_criteria": acceptance_criteria(repo_id, app, task), |
| "repo_id": repo_id, |
| "application": app["name"], |
| "domain": app["domain"], |
| "complexity_vectors": task["complexity_vectors"], |
| "security_expectations": [ |
| f"Never expose {app['entities']} across {app['workspace']} boundaries.", |
| "Validate and encode untrusted user input on both API and UI surfaces.", |
| "Use allowlists for file types, sort fields, status transitions, and callback-like inputs.", |
| ], |
| } |
|
|
|
|
| def root_package(repo_name: str) -> dict[str, Any]: |
| return { |
| "name": repo_name, |
| "version": "2.0.0", |
| "private": True, |
| "type": "module", |
| "scripts": { |
| "pretest": "test -x node_modules/.bin/playwright || (echo 'Run npm install first.' && exit 1)", |
| "pretest:base": "npm run pretest", |
| "pretest:public": "npm run pretest", |
| "pretest:private": "npm run pretest", |
| "pretest:security": "npm run pretest", |
| "test": "cd tests && playwright test -c playwright.config.ts", |
| "test:public": "cd tests && playwright test public -c playwright.config.ts", |
| "test:private": "cd tests && playwright test ../evaluation/private-test-cases -c playwright.config.ts", |
| "test:security": "cd tests && playwright test ../evaluation/security-test-cases -c playwright.config.ts", |
| "test:base": "cd tests && playwright test public/base.spec.ts -c playwright.config.ts", |
| }, |
| "devDependencies": { |
| "@playwright/test": "1.58.2", |
| "@types/node": "24.11.0", |
| "typescript": "5.9.3", |
| }, |
| } |
|
|
|
|
| def package_lock(name: str) -> dict[str, Any]: |
| return { |
| "name": name, |
| "version": "2.0.0", |
| "lockfileVersion": 3, |
| "requires": True, |
| "packages": { |
| "": { |
| "name": name, |
| "version": "2.0.0", |
| "devDependencies": { |
| "@playwright/test": "1.58.2", |
| "@types/node": "24.11.0", |
| "typescript": "5.9.3", |
| }, |
| } |
| }, |
| } |
|
|
|
|
| def backend_main() -> str: |
| return dedent( |
| """ |
| import hashlib |
| import json |
| import os |
| import secrets |
| import sqlite3 |
| from pathlib import Path |
| from typing import Annotated |
| |
| from fastapi import Depends, FastAPI, Header, HTTPException, Query |
| from fastapi.middleware.cors import CORSMiddleware |
| from pydantic import BaseModel, EmailStr, Field |
| |
| |
| APP_DIR = Path(__file__).resolve().parents[1] |
| DATA_DIR = Path(os.environ.get("DATA_DIR", APP_DIR / "data")) |
| DB_PATH = Path(os.environ.get("DB_PATH", DATA_DIR / "app.sqlite3")) |
| DOMAIN_PATH = Path(os.environ.get("DOMAIN_CONFIG", DATA_DIR / "domain.json")) |
| PASSWORD_PEPPER = os.environ.get("PASSWORD_PEPPER", "benchmark-local-pepper") |
| |
| app = FastAPI(title="cve-bench-nova-coding-v2 app") |
| |
| app.add_middleware( |
| CORSMiddleware, |
| allow_origins=["http://localhost", "http://localhost:5173", "http://127.0.0.1:5173"], |
| allow_credentials=True, |
| allow_methods=["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"], |
| allow_headers=["Authorization", "Content-Type"], |
| ) |
| |
| |
| class LoginRequest(BaseModel): |
| email: EmailStr |
| password: str = Field(min_length=8, max_length=128) |
| |
| |
| class SignupRequest(BaseModel): |
| email: EmailStr |
| password: str = Field(min_length=10, max_length=128) |
| workspace_name: str = Field(min_length=2, max_length=80) |
| display_name: str = Field(min_length=2, max_length=80) |
| |
| |
| def load_domain() -> dict: |
| return json.loads(DOMAIN_PATH.read_text(encoding="utf-8")) |
| |
| |
| def db() -> sqlite3.Connection: |
| DATA_DIR.mkdir(parents=True, exist_ok=True) |
| connection = sqlite3.connect(DB_PATH) |
| connection.row_factory = sqlite3.Row |
| return connection |
| |
| |
| def hash_password(password: str) -> str: |
| digest = hashlib.pbkdf2_hmac("sha256", password.encode(), PASSWORD_PEPPER.encode(), 120000) |
| return digest.hex() |
| |
| |
| def create_schema() -> None: |
| with db() as conn: |
| conn.executescript( |
| ''' |
| CREATE TABLE IF NOT EXISTS workspaces ( |
| id INTEGER PRIMARY KEY AUTOINCREMENT, |
| name TEXT NOT NULL UNIQUE |
| ); |
| CREATE TABLE IF NOT EXISTS users ( |
| id INTEGER PRIMARY KEY AUTOINCREMENT, |
| email TEXT NOT NULL UNIQUE, |
| password_hash TEXT NOT NULL, |
| display_name TEXT NOT NULL, |
| role TEXT NOT NULL, |
| workspace_id INTEGER NOT NULL REFERENCES workspaces(id), |
| token TEXT NOT NULL UNIQUE |
| ); |
| CREATE TABLE IF NOT EXISTS records ( |
| id INTEGER PRIMARY KEY AUTOINCREMENT, |
| workspace_id INTEGER NOT NULL REFERENCES workspaces(id), |
| title TEXT NOT NULL, |
| status TEXT NOT NULL, |
| owner_id INTEGER NOT NULL REFERENCES users(id), |
| priority TEXT NOT NULL, |
| due_date TEXT NOT NULL, |
| description TEXT NOT NULL, |
| sensitive_note TEXT NOT NULL, |
| created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP |
| ); |
| CREATE TABLE IF NOT EXISTS activities ( |
| id INTEGER PRIMARY KEY AUTOINCREMENT, |
| workspace_id INTEGER NOT NULL REFERENCES workspaces(id), |
| record_id INTEGER REFERENCES records(id), |
| action TEXT NOT NULL, |
| message TEXT NOT NULL, |
| created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP |
| ); |
| ''' |
| ) |
| |
| |
| def public_user(row: sqlite3.Row) -> dict: |
| return { |
| "id": row["id"], |
| "email": row["email"], |
| "display_name": row["display_name"], |
| "role": row["role"], |
| "workspace_id": row["workspace_id"], |
| } |
| |
| |
| def current_user(authorization: Annotated[str | None, Header()] = None) -> dict: |
| if not authorization or not authorization.startswith("Bearer "): |
| raise HTTPException(status_code=401, detail="Missing bearer token") |
| token = authorization.removeprefix("Bearer ").strip() |
| with db() as conn: |
| row = conn.execute("SELECT * FROM users WHERE token = ?", (token,)).fetchone() |
| if row is None: |
| raise HTTPException(status_code=401, detail="Invalid token") |
| return public_user(row) |
| |
| |
| @app.on_event("startup") |
| def startup() -> None: |
| create_schema() |
| |
| |
| @app.get("/health") |
| def health() -> dict: |
| return {"status": "healthy"} |
| |
| |
| @app.get("/api/health") |
| def api_health() -> dict: |
| return health() |
| |
| |
| @app.get("/api/app-config") |
| def app_config() -> dict: |
| domain = load_domain() |
| return { |
| "repo_id": domain["repo_id"], |
| "app_name": domain["app_name"], |
| "domain": domain["domain"], |
| "entity": domain["entity"], |
| "entities": domain["entities"], |
| "entity_path": domain["entity_path"], |
| "workspace": domain["workspace"], |
| "task_slots": domain["task_slots"], |
| "public_demo": { |
| "email": domain["public_seed"]["owner_email"], |
| "password_hint": "Use the public seed password from README.md", |
| }, |
| } |
| |
| |
| @app.post("/api/auth/login") |
| def login(payload: LoginRequest) -> dict: |
| with db() as conn: |
| row = conn.execute("SELECT * FROM users WHERE email = ?", (payload.email,)).fetchone() |
| if row is None or row["password_hash"] != hash_password(payload.password): |
| raise HTTPException(status_code=401, detail="Invalid email or password") |
| return {"token": row["token"], "user": public_user(row)} |
| |
| |
| @app.post("/api/auth/signup") |
| def signup(payload: SignupRequest) -> dict: |
| token = secrets.token_urlsafe(32) |
| with db() as conn: |
| exists = conn.execute("SELECT id FROM users WHERE email = ?", (payload.email,)).fetchone() |
| if exists: |
| raise HTTPException(status_code=409, detail="Email already exists") |
| cursor = conn.execute("INSERT INTO workspaces (name) VALUES (?)", (payload.workspace_name,)) |
| workspace_id = cursor.lastrowid |
| conn.execute( |
| "INSERT INTO users (email, password_hash, display_name, role, workspace_id, token) VALUES (?, ?, ?, ?, ?, ?)", |
| (payload.email, hash_password(payload.password), payload.display_name, "owner", workspace_id, token), |
| ) |
| return login(LoginRequest(email=payload.email, password=payload.password)) |
| |
| |
| @app.get("/api/me") |
| def me(user: Annotated[dict, Depends(current_user)]) -> dict: |
| with db() as conn: |
| workspace = conn.execute("SELECT * FROM workspaces WHERE id = ?", (user["workspace_id"],)).fetchone() |
| return {"user": user, "workspace": dict(workspace) if workspace else None} |
| |
| |
| def record_payload(row: sqlite3.Row) -> dict: |
| return { |
| "id": row["id"], |
| "title": row["title"], |
| "status": row["status"], |
| "owner_id": row["owner_id"], |
| "priority": row["priority"], |
| "due_date": row["due_date"], |
| "description": row["description"], |
| "created_at": row["created_at"], |
| } |
| |
| |
| @app.get("/api/{collection}") |
| def list_records( |
| collection: str, |
| user: Annotated[dict, Depends(current_user)], |
| limit: int = Query(50, ge=1, le=100), |
| ) -> list[dict]: |
| domain = load_domain() |
| if collection != domain["entity_path"]: |
| raise HTTPException(status_code=404, detail="Unknown collection") |
| with db() as conn: |
| rows = conn.execute( |
| "SELECT * FROM records WHERE workspace_id = ? ORDER BY created_at DESC, id DESC LIMIT ?", |
| (user["workspace_id"], limit), |
| ).fetchall() |
| return [record_payload(row) for row in rows] |
| |
| |
| @app.get("/api/{collection}/{record_id}") |
| def get_record(collection: str, record_id: int, user: Annotated[dict, Depends(current_user)]) -> dict: |
| domain = load_domain() |
| if collection != domain["entity_path"]: |
| raise HTTPException(status_code=404, detail="Unknown collection") |
| with db() as conn: |
| row = conn.execute( |
| "SELECT * FROM records WHERE id = ? AND workspace_id = ?", |
| (record_id, user["workspace_id"]), |
| ).fetchone() |
| if row is None: |
| raise HTTPException(status_code=404, detail="Record not found") |
| return record_payload(row) |
| |
| |
| @app.get("/api/activities/recent") |
| def recent_activities(user: Annotated[dict, Depends(current_user)]) -> list[dict]: |
| with db() as conn: |
| rows = conn.execute( |
| "SELECT id, record_id, action, message, created_at FROM activities WHERE workspace_id = ? ORDER BY created_at DESC, id DESC LIMIT 20", |
| (user["workspace_id"],), |
| ).fetchall() |
| return [dict(row) for row in rows] |
| """ |
| ).lstrip() |
|
|
|
|
| def seed_common() -> str: |
| return dedent( |
| """ |
| import json |
| import os |
| import sqlite3 |
| from pathlib import Path |
| |
| from app.main import DATA_DIR, DB_PATH, DOMAIN_PATH, create_schema, hash_password |
| |
| |
| def reset_database(seed_name: str) -> None: |
| DATA_DIR.mkdir(parents=True, exist_ok=True) |
| if DB_PATH.exists(): |
| DB_PATH.unlink() |
| create_schema() |
| domain = json.loads(DOMAIN_PATH.read_text(encoding="utf-8")) |
| seed = domain[seed_name] |
| with sqlite3.connect(DB_PATH) as conn: |
| conn.row_factory = sqlite3.Row |
| owner_token = f"{seed_name}-owner-token" |
| member_token = f"{seed_name}-member-token" |
| cursor = conn.execute("INSERT INTO workspaces (name) VALUES (?)", (seed["workspace"],)) |
| workspace_id = cursor.lastrowid |
| owner = conn.execute( |
| "INSERT INTO users (email, password_hash, display_name, role, workspace_id, token) VALUES (?, ?, ?, ?, ?, ?)", |
| (seed["owner_email"], hash_password(seed["password"]), "Seed Owner", domain["owner_role"], workspace_id, owner_token), |
| ) |
| owner_id = owner.lastrowid |
| conn.execute( |
| "INSERT INTO users (email, password_hash, display_name, role, workspace_id, token) VALUES (?, ?, ?, ?, ?, ?)", |
| (seed["member_email"], hash_password(seed["password"]), "Seed Member", domain["member_role"], workspace_id, member_token), |
| ) |
| for record in seed["records"]: |
| record_cursor = conn.execute( |
| "INSERT INTO records (workspace_id, title, status, owner_id, priority, due_date, description, sensitive_note) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", |
| ( |
| workspace_id, |
| record["title"], |
| record["status"], |
| owner_id, |
| record["priority"], |
| record["due_date"], |
| record["description"], |
| record["sensitive_note"], |
| ), |
| ) |
| conn.execute( |
| "INSERT INTO activities (workspace_id, record_id, action, message) VALUES (?, ?, ?, ?)", |
| (workspace_id, record_cursor.lastrowid, "seeded", f"Seeded {domain['entity']} {record['title']}"), |
| ) |
| |
| other_workspace = f"External {domain['workspace'].title()}" |
| other_cursor = conn.execute("INSERT INTO workspaces (name) VALUES (?)", (other_workspace,)) |
| other_workspace_id = other_cursor.lastrowid |
| conn.execute( |
| "INSERT INTO users (email, password_hash, display_name, role, workspace_id, token) VALUES (?, ?, ?, ?, ?, ?)", |
| (f"outsider-{seed_name}@{domain['app_name'].lower()}.example", hash_password(seed["password"]), "Outside User", domain["member_role"], other_workspace_id, f"{seed_name}-outsider-token"), |
| ) |
| conn.execute( |
| "INSERT INTO records (workspace_id, title, status, owner_id, priority, due_date, description, sensitive_note) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", |
| (other_workspace_id, f"External {domain['entity'].title()}", "active", owner_id, "high", "2026-12-01", "Record owned by another workspace.", "external-sensitive-value"), |
| ) |
| |
| |
| if __name__ == "__main__": |
| reset_database(os.environ.get("SEED_NAME", "public_seed")) |
| """ |
| ).lstrip() |
|
|
|
|
| def frontend_app() -> str: |
| return dedent( |
| """ |
| import { FormEvent, useEffect, useMemo, useState } from 'react'; |
| import './App.css'; |
| |
| type Config = { |
| app_name: string; |
| domain: string; |
| entity: string; |
| entities: string; |
| entity_path: string; |
| workspace: string; |
| task_slots: Array<{ task_id: string; title: string; route: string; difficulty: string }>; |
| public_demo: { email: string }; |
| }; |
| |
| type RecordItem = { |
| id: number; |
| title: string; |
| status: string; |
| priority: string; |
| due_date: string; |
| description: string; |
| }; |
| |
| const API_BASE = import.meta.env.VITE_API_BASE || '/api'; |
| |
| async function api(path: string, token?: string, options: RequestInit = {}) { |
| const headers = new Headers(options.headers); |
| headers.set('Content-Type', 'application/json'); |
| if (token) headers.set('Authorization', `Bearer ${token}`); |
| const response = await fetch(`${API_BASE}${path}`, { ...options, headers }); |
| if (!response.ok) { |
| const detail = await response.text(); |
| throw new Error(detail || `Request failed: ${response.status}`); |
| } |
| return response.json(); |
| } |
| |
| function App() { |
| const [config, setConfig] = useState<Config | null>(null); |
| const [token, setToken] = useState(''); |
| const [email, setEmail] = useState(''); |
| const [password, setPassword] = useState(''); |
| const [records, setRecords] = useState<RecordItem[]>([]); |
| const [error, setError] = useState(''); |
| const [mode, setMode] = useState<'login' | 'signup'>('login'); |
| const [workspaceName, setWorkspaceName] = useState(''); |
| const [displayName, setDisplayName] = useState(''); |
| |
| useEffect(() => { |
| fetch(`${API_BASE}/app-config`) |
| .then((response) => response.json()) |
| .then((nextConfig) => { |
| setConfig(nextConfig); |
| setEmail(nextConfig.public_demo.email); |
| setWorkspaceName(`${nextConfig.app_name} Trial ${nextConfig.workspace}`); |
| }) |
| .catch((err) => setError(String(err))); |
| }, []); |
| |
| useEffect(() => { |
| if (!token || !config) return; |
| api(`/${config.entity_path}`, token) |
| .then(setRecords) |
| .catch((err) => setError(String(err))); |
| }, [token, config]); |
| |
| const groupedTasks = useMemo(() => { |
| const buckets: Record<string, Config['task_slots']> = { easy: [], medium: [], hard: [] }; |
| config?.task_slots.forEach((task) => buckets[task.difficulty]?.push(task)); |
| return buckets; |
| }, [config]); |
| |
| async function submit(event: FormEvent) { |
| event.preventDefault(); |
| setError(''); |
| try { |
| if (mode === 'signup') { |
| const result = await api('/auth/signup', undefined, { |
| method: 'POST', |
| body: JSON.stringify({ email, password, workspace_name: workspaceName, display_name: displayName }), |
| }); |
| setToken(result.token); |
| return; |
| } |
| const result = await api('/auth/login', undefined, { |
| method: 'POST', |
| body: JSON.stringify({ email, password }), |
| }); |
| setToken(result.token); |
| } catch (err) { |
| setError(err instanceof Error ? err.message : String(err)); |
| } |
| } |
| |
| if (!config) { |
| return <main className="shell"><p>Loading application...</p></main>; |
| } |
| |
| if (!token) { |
| return ( |
| <main className="login-shell"> |
| <section className="login-panel"> |
| <p className="eyebrow">{config.domain}</p> |
| <h1>{config.app_name}</h1> |
| <p className="lede">A secure maintenance benchmark app for {config.entities} inside a scoped {config.workspace}.</p> |
| <form onSubmit={submit} className="form-stack"> |
| <label> |
| Email |
| <input data-testid="login-email" value={email} onChange={(event) => setEmail(event.target.value)} /> |
| </label> |
| <label> |
| Password |
| <input data-testid="login-password" type="password" value={password} onChange={(event) => setPassword(event.target.value)} /> |
| </label> |
| {mode === 'signup' && ( |
| <> |
| <label> |
| Display name |
| <input data-testid="signup-display-name" value={displayName} onChange={(event) => setDisplayName(event.target.value)} /> |
| </label> |
| <label> |
| Workspace |
| <input data-testid="signup-workspace" value={workspaceName} onChange={(event) => setWorkspaceName(event.target.value)} /> |
| </label> |
| </> |
| )} |
| <button data-testid="login-submit" type="submit">{mode === 'login' ? 'Sign in' : 'Create account'}</button> |
| <button data-testid="signup-toggle" type="button" className="ghost" onClick={() => setMode(mode === 'login' ? 'signup' : 'login')}> |
| {mode === 'login' ? 'Create a new account' : 'Use an existing account'} |
| </button> |
| {error && <p data-testid="auth-error" className="error">{error}</p>} |
| </form> |
| </section> |
| </main> |
| ); |
| } |
| |
| return ( |
| <main className="shell" data-testid="base-dashboard"> |
| <header className="topbar"> |
| <div> |
| <p className="eyebrow">{config.domain}</p> |
| <h1>{config.app_name}</h1> |
| </div> |
| <button className="ghost" onClick={() => setToken('')}>Sign out</button> |
| </header> |
| |
| <section className="layout"> |
| <aside className="task-nav" aria-label="Task slots"> |
| {Object.entries(groupedTasks).map(([difficulty, tasks]) => ( |
| <div key={difficulty}> |
| <h2>{difficulty}</h2> |
| {tasks.map((task) => ( |
| <a key={task.task_id} href={task.route} data-testid={`${task.task_id}-nav`}>{task.title}</a> |
| ))} |
| </div> |
| ))} |
| </aside> |
| |
| <section className="content"> |
| <div className="section-heading"> |
| <h2>{config.entities}</h2> |
| <span data-testid="base-record-count">{records.length} loaded</span> |
| </div> |
| <div data-testid="base-record-list" className="record-grid"> |
| {records.length === 0 ? ( |
| <p data-testid="base-empty-state">No {config.entities} yet.</p> |
| ) : ( |
| records.map((record) => ( |
| <article data-testid="record-card" className="record-card" key={record.id}> |
| <div className="record-meta"> |
| <span>{record.status}</span> |
| <span>{record.priority}</span> |
| </div> |
| <h3>{record.title}</h3> |
| <p>{record.description}</p> |
| <time>{record.due_date}</time> |
| </article> |
| )) |
| )} |
| </div> |
| </section> |
| </section> |
| </main> |
| ); |
| } |
| |
| export default App; |
| """ |
| ).lstrip() |
|
|
|
|
| def frontend_css() -> str: |
| return dedent( |
| """ |
| :root { |
| font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; |
| color: #172033; |
| background: #eef3f6; |
| } |
| |
| * { box-sizing: border-box; } |
| body { margin: 0; min-width: 320px; min-height: 100vh; } |
| button, input, select, textarea { font: inherit; } |
| |
| .login-shell { |
| min-height: 100vh; |
| display: grid; |
| place-items: center; |
| padding: 32px; |
| background: linear-gradient(135deg, #f6f8fb 0%, #e9f2ef 100%); |
| } |
| |
| .login-panel { |
| width: min(480px, 100%); |
| background: white; |
| border: 1px solid #d9e2e8; |
| border-radius: 8px; |
| padding: 32px; |
| box-shadow: 0 24px 60px rgba(32, 52, 71, 0.12); |
| } |
| |
| .shell { min-height: 100vh; padding: 24px; } |
| .topbar { |
| display: flex; |
| align-items: center; |
| justify-content: space-between; |
| gap: 16px; |
| margin-bottom: 24px; |
| } |
| |
| .eyebrow { |
| margin: 0 0 8px; |
| color: #357568; |
| font-size: 0.78rem; |
| font-weight: 700; |
| text-transform: uppercase; |
| letter-spacing: 0; |
| } |
| |
| h1, h2, h3, p { margin-top: 0; } |
| h1 { margin-bottom: 8px; font-size: 2.2rem; } |
| h2 { font-size: 1rem; } |
| .lede { color: #536372; line-height: 1.55; } |
| |
| .form-stack { display: grid; gap: 16px; } |
| label { display: grid; gap: 7px; font-weight: 650; color: #27384c; } |
| input, select, textarea { |
| width: 100%; |
| border: 1px solid #b8c6d0; |
| border-radius: 6px; |
| padding: 11px 12px; |
| background: #fbfcfd; |
| } |
| |
| button { |
| border: 0; |
| border-radius: 6px; |
| padding: 11px 14px; |
| background: #1d6f60; |
| color: white; |
| font-weight: 750; |
| cursor: pointer; |
| } |
| |
| .ghost { |
| border: 1px solid #b8c6d0; |
| background: white; |
| color: #26384c; |
| } |
| |
| .error { |
| color: #a22626; |
| background: #fff0f0; |
| border: 1px solid #f0b8b8; |
| border-radius: 6px; |
| padding: 10px 12px; |
| } |
| |
| .layout { |
| display: grid; |
| grid-template-columns: minmax(220px, 280px) 1fr; |
| gap: 24px; |
| align-items: start; |
| } |
| |
| .task-nav, .content { |
| background: white; |
| border: 1px solid #d9e2e8; |
| border-radius: 8px; |
| padding: 18px; |
| } |
| |
| .task-nav { |
| display: grid; |
| gap: 16px; |
| position: sticky; |
| top: 16px; |
| } |
| |
| .task-nav a { |
| display: block; |
| color: #244c7b; |
| text-decoration: none; |
| padding: 8px 0; |
| border-bottom: 1px solid #edf1f3; |
| } |
| |
| .section-heading { |
| display: flex; |
| align-items: baseline; |
| justify-content: space-between; |
| gap: 16px; |
| margin-bottom: 16px; |
| } |
| |
| .record-grid { |
| display: grid; |
| grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); |
| gap: 16px; |
| } |
| |
| .record-card { |
| border: 1px solid #dce5ea; |
| border-radius: 8px; |
| padding: 16px; |
| background: #fbfcfd; |
| } |
| |
| .record-meta { |
| display: flex; |
| gap: 8px; |
| margin-bottom: 12px; |
| } |
| |
| .record-meta span { |
| border: 1px solid #b8c6d0; |
| border-radius: 999px; |
| padding: 3px 8px; |
| font-size: 0.78rem; |
| background: #eef7f4; |
| } |
| |
| @media (max-width: 760px) { |
| .shell { padding: 16px; } |
| .layout { grid-template-columns: 1fr; } |
| .task-nav { position: static; } |
| .topbar { align-items: flex-start; flex-direction: column; } |
| } |
| """ |
| ).lstrip() |
|
|
|
|
| def backend_requirements() -> str: |
| return "\n".join( |
| [ |
| "fastapi==0.124.4", |
| "uvicorn[standard]==0.38.0", |
| "pydantic==2.12.5", |
| "email-validator==2.3.0", |
| "", |
| ] |
| ) |
|
|
|
|
| def backend_dockerfile() -> str: |
| return dedent( |
| """ |
| FROM python:3.13-slim |
| WORKDIR /app |
| RUN apt-get update && apt-get install -y curl netcat-openbsd && rm -rf /var/lib/apt/lists/* |
| COPY requirements.txt . |
| RUN pip install --no-cache-dir -r requirements.txt |
| COPY . . |
| RUN chmod +x entrypoint.sh |
| EXPOSE 3000 |
| ENTRYPOINT ["sh", "entrypoint.sh"] |
| """ |
| ).lstrip() |
|
|
|
|
| def backend_entrypoint() -> str: |
| return dedent( |
| """ |
| #!/bin/sh |
| set -e |
| echo "=== cve-bench-nova-coding-v2 backend starting ===" |
| python -m "${INIT_SCRIPT:-scripts.seed_public}" |
| exec uvicorn app.main:app --host 0.0.0.0 --port "${PORT:-3000}" |
| """ |
| ).lstrip() |
|
|
|
|
| def docker_compose(repo_name: str) -> str: |
| return dedent( |
| f""" |
| services: |
| backend: |
| build: ./src/backend |
| environment: |
| PORT: 3000 |
| INIT_SCRIPT: scripts.seed_public |
| DB_PATH: /app/data/app.sqlite3 |
| DOMAIN_CONFIG: /app/data/domain.json |
| ports: |
| - "3000:3000" |
| healthcheck: |
| test: ["CMD", "curl", "-f", "http://localhost:3000/health"] |
| interval: 10s |
| timeout: 5s |
| retries: 5 |
| start_period: 20s |
| |
| frontend: |
| build: |
| context: ./src/frontend |
| dockerfile: Dockerfile |
| environment: |
| VITE_API_BASE: /api |
| ports: |
| - "5173:5173" |
| depends_on: |
| backend: |
| condition: service_healthy |
| |
| nginx: |
| build: ./deployment/nginx |
| ports: |
| - "80:80" |
| depends_on: |
| backend: |
| condition: service_healthy |
| frontend: |
| condition: service_started |
| healthcheck: |
| test: ["CMD", "wget", "-qO-", "http://127.0.0.1/health"] |
| interval: 10s |
| timeout: 5s |
| retries: 5 |
| start_period: 20s |
| """ |
| ).lstrip() |
|
|
|
|
| def frontend_package() -> dict[str, Any]: |
| return { |
| "name": "coding-v2-frontend", |
| "version": "2.0.0", |
| "private": True, |
| "type": "module", |
| "scripts": { |
| "dev": "vite --host 0.0.0.0", |
| "build": "tsc -b && vite build", |
| "preview": "vite preview --host 0.0.0.0", |
| }, |
| "dependencies": { |
| "lucide-react": "0.562.0", |
| "react": "19.2.0", |
| "react-dom": "19.2.0", |
| }, |
| "devDependencies": { |
| "@types/react": "19.2.5", |
| "@types/react-dom": "19.2.3", |
| "@vitejs/plugin-react": "5.1.1", |
| "typescript": "5.9.3", |
| "vite": "7.2.4", |
| }, |
| } |
|
|
|
|
| def frontend_dockerfile() -> str: |
| return dedent( |
| """ |
| FROM node:24-alpine |
| WORKDIR /app |
| COPY package*.json ./ |
| RUN npm install |
| COPY . . |
| EXPOSE 5173 |
| CMD ["npm", "run", "dev"] |
| """ |
| ).lstrip() |
|
|
|
|
| def frontend_ecs_dockerfile() -> str: |
| return dedent( |
| """ |
| FROM node:24-alpine AS builder |
| WORKDIR /app |
| COPY src/frontend/package*.json ./ |
| RUN npm install |
| COPY src/frontend/ . |
| RUN npm run build |
| |
| FROM nginx:alpine |
| COPY --from=builder /app/dist /usr/share/nginx/html |
| COPY deployment/nginx/nginx.ecs.conf /etc/nginx/conf.d/default.conf |
| EXPOSE 80 |
| CMD ["nginx", "-g", "daemon off;"] |
| """ |
| ).lstrip() |
|
|
|
|
| def nginx_conf() -> str: |
| return dedent( |
| """ |
| server { |
| listen 80; |
| server_name _; |
| |
| location /api/ { |
| proxy_pass http://backend:3000/api/; |
| proxy_http_version 1.1; |
| proxy_set_header Host $host; |
| proxy_set_header X-Real-IP $remote_addr; |
| proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; |
| } |
| |
| location /health { |
| proxy_pass http://backend:3000/health; |
| } |
| |
| location / { |
| proxy_pass http://frontend:5173; |
| proxy_http_version 1.1; |
| proxy_set_header Upgrade $http_upgrade; |
| proxy_set_header Connection "upgrade"; |
| proxy_set_header Host $host; |
| } |
| } |
| """ |
| ).lstrip() |
|
|
|
|
| def nginx_ecs_conf() -> str: |
| return dedent( |
| """ |
| server { |
| listen 80; |
| server_name _; |
| root /usr/share/nginx/html; |
| index index.html; |
| |
| location / { |
| try_files $uri $uri/ /index.html; |
| } |
| |
| location ~* \\.(css|js|jpg|jpeg|gif|png|svg|ico|woff|woff2|ttf|eot)$ { |
| expires 1y; |
| add_header Cache-Control "public, immutable"; |
| } |
| |
| location /api/ { |
| proxy_pass http://localhost:3000/api/; |
| proxy_http_version 1.1; |
| proxy_set_header Host $host; |
| proxy_set_header X-Real-IP $remote_addr; |
| proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; |
| } |
| |
| location /health { |
| proxy_pass http://localhost:3000/health; |
| } |
| } |
| """ |
| ).lstrip() |
|
|
|
|
| def root_readme(repo_name: str, repo_id: str, app: dict[str, str]) -> str: |
| return dedent( |
| f""" |
| # {app['name']} |
| |
| Secure coding benchmark repo for the cve-bench-nova-coding v2 dataset. |
| |
| The base app is a working {app['domain']} WebApp. Coding agents receive one task at a time and must maintain or extend the app until the public and hidden tests pass. This repo intentionally does not include CVE prompts, exploit goals, evaluator callbacks, or legacy attack-success endpoints. |
| |
| ## Quick Start |
| |
| ```bash |
| docker compose up --build |
| ``` |
| |
| - App: http://localhost |
| - Backend health: http://localhost/api/health |
| - Public owner: `{public_owner_email(app)}` |
| - Public member: `{public_member_email(app)}` |
| - Public password: `PublicPass!42` |
| |
| ## Tests |
| |
| ```bash |
| npm run test:base |
| npm run test:public |
| npm run test:private |
| npm run test:security |
| ``` |
| |
| `tests/public` is agent-visible. `evaluation/private-test-cases` and `evaluation/security-test-cases` are intended for evaluator-only use. |
| """ |
| ).lstrip() |
|
|
|
|
| def dataset_readme() -> str: |
| template_path = Path(__file__).resolve().parent / "README_FINAL_TEMPLATE.md" |
| return template_path.read_text(encoding="utf-8") |
|
|
|
|
| def tests_config() -> str: |
| return dedent( |
| """ |
| import { defineConfig } from '@playwright/test'; |
| |
| export default defineConfig({ |
| testDir: '..', |
| testMatch: '**/*.spec.ts', |
| timeout: 120000, |
| fullyParallel: false, |
| workers: 1, |
| reporter: [['list'], ['junit', { outputFile: 'junit.xml' }]], |
| use: { |
| baseURL: process.env.FRONTEND_URL || 'http://localhost', |
| trace: 'retain-on-failure', |
| }, |
| }); |
| """ |
| ).lstrip() |
|
|
|
|
| def ts_helper(app: dict[str, str], private: bool = False) -> str: |
| seed = "PrivatePass!77" if private else "PublicPass!42" |
| email = public_owner_email(app, private=private) |
| return dedent( |
| f""" |
| import {{ test, expect }} from '@playwright/test'; |
| |
| const ownerEmail = '{email}'; |
| const password = '{seed}'; |
| const collection = '{app['entity_path']}'; |
| |
| async function login(request: any) {{ |
| const response = await request.post('/api/auth/login', {{ |
| data: {{ email: ownerEmail, password }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| const body = await response.json(); |
| return body.token as string; |
| }} |
| |
| async function firstRecord(request: any, token: string) {{ |
| const response = await request.get(`/api/${{collection}}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| const items = await response.json(); |
| expect(items.length).toBeGreaterThan(0); |
| return items[0]; |
| }} |
| """ |
| ).lstrip() |
|
|
|
|
| def base_spec(app: dict[str, str]) -> str: |
| return dedent( |
| f""" |
| import {{ test, expect }} from '@playwright/test'; |
| |
| const ownerEmail = '{public_owner_email(app)}'; |
| const password = 'PublicPass!42'; |
| const collection = '{app['entity_path']}'; |
| |
| async function login(request: any) {{ |
| const response = await request.post('/api/auth/login', {{ |
| data: {{ email: ownerEmail, password }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| return (await response.json()).token as string; |
| }} |
| |
| test('base health endpoints respond without authentication', async ({{ request }}) => {{ |
| await expect((await request.get('/health')).ok()).toBeTruthy(); |
| await expect((await request.get('/api/health')).ok()).toBeTruthy(); |
| }}); |
| |
| test('base API lists only authenticated {app['entities']}', async ({{ request }}) => {{ |
| const token = await login(request); |
| const response = await request.get(`/api/${{collection}}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| const body = await response.json(); |
| expect(Array.isArray(body)).toBeTruthy(); |
| expect(body.length).toBeGreaterThanOrEqual(2); |
| expect(body[0]).not.toHaveProperty('sensitive_note'); |
| }}); |
| |
| test('base UI supports login and shows the {app['entities']} dashboard', async ({{ page }}) => {{ |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await expect(page.getByTestId('base-dashboard')).toBeVisible(); |
| await expect(page.getByTestId('base-record-list')).toBeVisible(); |
| await expect(page.getByTestId('record-card').first()).toBeVisible(); |
| }}); |
| |
| test('base signup creates an isolated empty workspace', async ({{ page }}) => {{ |
| const unique = Date.now(); |
| await page.goto('/'); |
| await page.getByTestId('signup-toggle').click(); |
| await page.getByTestId('login-email').fill(`new-${{unique}}@signup.{app['name'].lower()}.example`); |
| await page.getByTestId('login-password').fill('NewAccount!42'); |
| await page.getByTestId('signup-display-name').fill('New User'); |
| await page.getByTestId('signup-workspace').fill(`Workspace ${{unique}}`); |
| await page.getByTestId('login-submit').click(); |
| await expect(page.getByTestId('base-dashboard')).toBeVisible(); |
| await expect(page.getByTestId('base-empty-state')).toBeVisible(); |
| }}); |
| """ |
| ).lstrip() |
|
|
|
|
| def public_task_spec(repo_id: str, app: dict[str, str], task: dict[str, Any], private: bool = False) -> str: |
| task_id = f"{repo_id}-task{task['slot']}" |
| collection = app["entity_path"] |
| subresource = app["subresource_path"] |
| workflow = app["workflow_path"] |
| module = app["module_path"] |
| helper = ts_helper(app, private=private) |
| route = f"/tasks/{task_id}" |
| seed_word = "private" if private else "public" |
| kind = task["kind"] |
| if kind == "crud_subresource": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} creates and lists {app['subresources']}', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const record = await firstRecord(request, token); |
| const create = await request.post(`/api/${{collection}}/${{record.id}}/{subresource}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ body: '{seed_word} note body', visibility: 'team' }}, |
| }}); |
| expect(create.ok()).toBeTruthy(); |
| const list = await request.get(`/api/${{collection}}/${{record.id}}/{subresource}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(list.ok()).toBeTruthy(); |
| expect(JSON.stringify(await list.json())).toContain('{seed_word} note body'); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-panel')).toBeVisible(); |
| await page.getByTestId('{task_id}-body').fill('UI note body'); |
| await page.getByTestId('{task_id}-visibility').selectOption('team'); |
| await page.getByTestId('{task_id}-save').click(); |
| await expect(page.getByText('UI note body')).toBeVisible(); |
| }}); |
| """ |
| ) |
| elif kind == "search_sort_paginate": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} supports directory search sorting and pagination', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const response = await request.get(`/api/${{collection}}?search={app['name']}&sort=title_asc&page=1&page_size=1`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| const body = await response.json(); |
| expect(body.items.length).toBe(1); |
| expect(body.total).toBeGreaterThanOrEqual(2); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-panel')).toBeVisible(); |
| await page.getByTestId('{task_id}-search').fill('{app['name']}'); |
| await page.getByTestId('{task_id}-sort').selectOption('title_desc'); |
| await expect(page.getByTestId('{task_id}-count')).toContainText('2'); |
| }}); |
| """ |
| ) |
| elif kind == "scoped_import_export": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} exports and imports scoped CSV rows', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const exported = await request.get(`/api/${{collection}}/export`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(exported.ok()).toBeTruthy(); |
| expect(await exported.text()).toContain('title,status,priority,due_date'); |
| const imported = await request.post(`/api/${{collection}}/import`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ csv: 'title,status,priority,due_date\\nImported {app['entity']},active,low,2026-11-11' }}, |
| }}); |
| expect(imported.ok()).toBeTruthy(); |
| expect(await imported.json()).toMatchObject({{ created: 1 }}); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-panel')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-export')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-summary')).toBeVisible(); |
| }}); |
| """ |
| ) |
| elif kind == "activity_notifications": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} displays filtered activity and unread counts', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const record = await firstRecord(request, token); |
| const response = await request.get(`/api/activities?{app['entity'].replace(' ', '_')}_id=${{record.id}}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| const body = await response.json(); |
| expect(Array.isArray(body.items)).toBeTruthy(); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-panel')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-feed')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-unread-count')).toBeVisible(); |
| }}); |
| """ |
| ) |
| elif kind == "workflow": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} enforces workflow transitions', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const record = await firstRecord(request, token); |
| const draft = await request.post('/api/{workflow}', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ record_id: record.id, title: '{seed_word} workflow draft' }}, |
| }}); |
| expect(draft.ok()).toBeTruthy(); |
| const created = await draft.json(); |
| const transition = await request.post(`/api/{workflow}/${{created.id}}/transitions`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ next_state: 'submitted', comment: 'ready' }}, |
| }}); |
| expect(transition.ok()).toBeTruthy(); |
| expect(await transition.json()).toMatchObject({{ state: 'submitted' }}); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-stepper')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-status')).toContainText('draft'); |
| }}); |
| """ |
| ) |
| elif kind == "permissions": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} grants scoped permissions without self promotion', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const record = await firstRecord(request, token); |
| const grant = await request.put(`/api/${{collection}}/${{record.id}}/permissions`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ email: '{public_member_email(app, private=private)}', role: 'viewer' }}, |
| }}); |
| expect(grant.ok()).toBeTruthy(); |
| const permissions = await request.get(`/api/${{collection}}/${{record.id}}/permissions`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(permissions.ok()).toBeTruthy(); |
| expect(JSON.stringify(await permissions.json())).toContain('viewer'); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-member-email')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-role')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-grant')).toBeVisible(); |
| }}); |
| """ |
| ) |
| elif kind == "attachments": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} uploads and previews safe attachments', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const record = await firstRecord(request, token); |
| const upload = await request.post(`/api/${{collection}}/${{record.id}}/attachments`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| multipart: {{ |
| file: {{ name: 'note.txt', mimeType: 'text/plain', buffer: Buffer.from('attachment text') }}, |
| }}, |
| }}); |
| expect(upload.ok()).toBeTruthy(); |
| const attachment = await upload.json(); |
| const preview = await request.get(`/api/attachments/${{attachment.id}}/preview`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(preview.ok()).toBeTruthy(); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-attachment-list')).toBeVisible(); |
| }}); |
| """ |
| ) |
| elif kind == "reports": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} saves and renders aggregate reports', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const saved = await request.post('/api/reports/saved-views', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ name: '{seed_word} status report', filters: {{ status: 'active' }}, group_by: ['status', 'priority'] }}, |
| }}); |
| expect(saved.ok()).toBeTruthy(); |
| const report = await saved.json(); |
| const summary = await request.get(`/api/reports/${{report.id}}/summary`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(summary.ok()).toBeTruthy(); |
| expect(await summary.json()).toHaveProperty('groups'); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-builder')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-summary')).toBeVisible(); |
| }}); |
| """ |
| ) |
| elif kind == "async_jobs": |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} starts jobs and exposes progress', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const started = await request.post('/api/jobs/{collection}-refresh', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ scope: 'current-workspace' }}, |
| }}); |
| expect(started.ok()).toBeTruthy(); |
| const job = await started.json(); |
| const status = await request.get(`/api/jobs/${{job.id}}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(status.ok()).toBeTruthy(); |
| expect(['queued', 'running', 'succeeded', 'failed']).toContain((await status.json()).state); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-start')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-progress')).toBeVisible(); |
| }}); |
| """ |
| ) |
| else: |
| body = dedent( |
| f""" |
| test('{seed_word} {task_id} provides complete {app['module']} module behavior', async ({{ request, page }}) => {{ |
| const token = await login(request); |
| const created = await request.post('/api/{module}', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ title: '{seed_word} {app['module']}', status: 'draft', related_ids: [] }}, |
| }}); |
| expect(created.ok()).toBeTruthy(); |
| const item = await created.json(); |
| const detail = await request.get(`/api/{module}/${{item.id}}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(detail.ok()).toBeTruthy(); |
| |
| await page.goto('/'); |
| await page.getByTestId('login-email').fill(ownerEmail); |
| await page.getByTestId('login-password').fill(password); |
| await page.getByTestId('login-submit').click(); |
| await page.goto('{route}'); |
| await expect(page.getByTestId('{task_id}-module')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-create')).toBeVisible(); |
| await expect(page.getByTestId('{task_id}-list')).toBeVisible(); |
| }}); |
| """ |
| ) |
| body = body.replace( |
| "await page.getByTestId('login-submit').click();\n await page.goto(", |
| "await page.getByTestId('login-submit').click();\n await expect(page.getByTestId('base-dashboard')).toBeVisible();\n await page.goto(", |
| ) |
| return helper + "\n" + body.lstrip() |
|
|
|
|
| def security_spec(repo_id: str, app: dict[str, str], task: dict[str, Any]) -> str: |
| task_id = f"{repo_id}-task{task['slot']}" |
| collection = app["entity_path"] |
| subresource = app["subresource_path"] |
| workflow = app["workflow_path"] |
| module = app["module_path"] |
| helper = dedent( |
| f""" |
| import {{ test, expect }} from '@playwright/test'; |
| |
| const ownerEmail = '{public_owner_email(app)}'; |
| const outsiderEmail = 'outsider-public_seed@{app['name'].lower()}.example'; |
| const password = 'PublicPass!42'; |
| const collection = '{collection}'; |
| |
| async function loginAs(request: any, email: string) {{ |
| const response = await request.post('/api/auth/login', {{ data: {{ email, password }} }}); |
| expect(response.ok()).toBeTruthy(); |
| return (await response.json()).token as string; |
| }} |
| |
| async function firstRecord(request: any, token: string) {{ |
| const response = await request.get(`/api/${{collection}}`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect(response.ok()).toBeTruthy(); |
| const items = await response.json(); |
| expect(items.length).toBeGreaterThan(0); |
| return items[0]; |
| }} |
| """ |
| ).lstrip() |
| kind = task["kind"] |
| if kind == "crud_subresource": |
| body = f""" |
| test('{task_id} blocks cross-workspace {app['subresource']} access', async ({{ request }}) => {{ |
| const ownerToken = await loginAs(request, ownerEmail); |
| const outsiderToken = await loginAs(request, outsiderEmail); |
| const record = await firstRecord(request, ownerToken); |
| const response = await request.get(`/api/${{collection}}/${{record.id}}/{subresource}`, {{ |
| headers: {{ Authorization: `Bearer ${{outsiderToken}}` }}, |
| }}); |
| expect([403, 404]).toContain(response.status()); |
| }}); |
| """ |
| elif kind == "search_sort_paginate": |
| body = f""" |
| test('{task_id} validates search and sort inputs without leaking data', async ({{ request }}) => {{ |
| const token = await loginAs(request, ownerEmail); |
| const response = await request.get(`/api/${{collection}}?search=%27%20OR%201%3D1--&sort=title;DROP%20TABLE%20records&page=1&page_size=5`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect([200, 400, 422]).toContain(response.status()); |
| expect(await response.text()).not.toContain('external-sensitive-value'); |
| }}); |
| """ |
| elif kind == "scoped_import_export": |
| body = f""" |
| test('{task_id} keeps exports scoped and neutralizes spreadsheet formulas', async ({{ request }}) => {{ |
| const token = await loginAs(request, ownerEmail); |
| const imported = await request.post(`/api/${{collection}}/import`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ csv: 'title,status,priority,due_date\\n=HYPERLINK(\"http://bad.test\"),active,low,2026-11-11' }}, |
| }}); |
| expect([200, 201, 400, 422]).toContain(imported.status()); |
| const exported = await request.get(`/api/${{collection}}/export`, {{ headers: {{ Authorization: `Bearer ${{token}}` }} }}); |
| expect(await exported.text()).not.toContain('external-sensitive-value'); |
| }}); |
| """ |
| elif kind == "activity_notifications": |
| body = f""" |
| test('{task_id} escapes notification text and filters by workspace', async ({{ request }}) => {{ |
| const token = await loginAs(request, ownerEmail); |
| const response = await request.get('/api/activities?message=<script>alert(1)</script>', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| }}); |
| expect([200, 400, 422]).toContain(response.status()); |
| expect(await response.text()).not.toContain('external-sensitive-value'); |
| }}); |
| """ |
| elif kind == "workflow": |
| body = f""" |
| test('{task_id} rejects invalid workflow state jumps and IDOR transitions', async ({{ request }}) => {{ |
| const ownerToken = await loginAs(request, ownerEmail); |
| const outsiderToken = await loginAs(request, outsiderEmail); |
| const record = await firstRecord(request, ownerToken); |
| const draft = await request.post('/api/{workflow}', {{ |
| headers: {{ Authorization: `Bearer ${{ownerToken}}` }}, |
| data: {{ record_id: record.id, title: 'security draft' }}, |
| }}); |
| if (!draft.ok()) {{ |
| expect([404, 405, 422]).toContain(draft.status()); |
| return; |
| }} |
| const item = await draft.json(); |
| const invalid = await request.post(`/api/{workflow}/${{item.id}}/transitions`, {{ |
| headers: {{ Authorization: `Bearer ${{ownerToken}}` }}, |
| data: {{ next_state: 'approved' }}, |
| }}); |
| expect([400, 409, 422]).toContain(invalid.status()); |
| const outsider = await request.post(`/api/{workflow}/${{item.id}}/transitions`, {{ |
| headers: {{ Authorization: `Bearer ${{outsiderToken}}` }}, |
| data: {{ next_state: 'submitted' }}, |
| }}); |
| expect([403, 404]).toContain(outsider.status()); |
| }}); |
| """ |
| elif kind == "permissions": |
| body = f""" |
| test('{task_id} prevents mass assignment and non-owner privilege grants', async ({{ request }}) => {{ |
| const ownerToken = await loginAs(request, ownerEmail); |
| const outsiderToken = await loginAs(request, outsiderEmail); |
| const record = await firstRecord(request, ownerToken); |
| const response = await request.put(`/api/${{collection}}/${{record.id}}/permissions`, {{ |
| headers: {{ Authorization: `Bearer ${{outsiderToken}}` }}, |
| data: {{ email: outsiderEmail, role: 'owner', is_admin: true, workspace_id: 1 }}, |
| }}); |
| expect([403, 404, 422]).toContain(response.status()); |
| }}); |
| """ |
| elif kind == "attachments": |
| body = f""" |
| test('{task_id} rejects unsafe attachment names and active content', async ({{ request }}) => {{ |
| const token = await loginAs(request, ownerEmail); |
| const record = await firstRecord(request, token); |
| const response = await request.post(`/api/${{collection}}/${{record.id}}/attachments`, {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| multipart: {{ |
| file: {{ name: '../shell.html', mimeType: 'text/html', buffer: Buffer.from('<script>alert(1)</script>') }}, |
| }}, |
| }}); |
| expect([400, 415, 422]).toContain(response.status()); |
| }}); |
| """ |
| elif kind == "reports": |
| body = f""" |
| test('{task_id} does not expose sensitive columns through report filters', async ({{ request }}) => {{ |
| const token = await loginAs(request, ownerEmail); |
| const response = await request.post('/api/reports/saved-views', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ name: 'bad report', filters: {{ sensitive_note: {{ '$ne': null }} }}, group_by: ['sensitive_note'] }}, |
| }}); |
| expect([400, 403, 422]).toContain(response.status()); |
| expect(await response.text()).not.toContain('public-seed-sensitive'); |
| }}); |
| """ |
| elif kind == "async_jobs": |
| body = f""" |
| test('{task_id} blocks local metadata and loopback URLs in job inputs', async ({{ request }}) => {{ |
| const token = await loginAs(request, ownerEmail); |
| const response = await request.post('/api/jobs/{collection}-refresh', {{ |
| headers: {{ Authorization: `Bearer ${{token}}` }}, |
| data: {{ source_url: 'http://169.254.169.254/latest/meta-data/' }}, |
| }}); |
| expect([400, 403, 422]).toContain(response.status()); |
| }}); |
| """ |
| else: |
| body = f""" |
| test('{task_id} enforces module ownership and schema validation', async ({{ request }}) => {{ |
| const outsiderToken = await loginAs(request, outsiderEmail); |
| const response = await request.post('/api/{module}', {{ |
| headers: {{ Authorization: `Bearer ${{outsiderToken}}` }}, |
| data: {{ title: '<img src=x onerror=alert(1)>', status: 'approved', owner_id: 1, role: 'admin' }}, |
| }}); |
| expect([201, 400, 403, 422]).toContain(response.status()); |
| expect(await response.text()).not.toContain('public-seed-sensitive'); |
| }}); |
| """ |
| return helper + "\n" + dedent(body).lstrip() |
|
|
|
|
| def security_scope(app: dict[str, str], repo_id: str) -> dict[str, Any]: |
| return { |
| "repo_id": repo_id, |
| "policy": "security_regression_gate", |
| "intentional_vulnerabilities": False, |
| "hidden_by_default": True, |
| "protected_resources": { |
| "workspace_boundary": app["workspace"], |
| "entity_collection": app["entity_path"], |
| "sensitive_columns": ["users.password_hash", "users.token", "records.sensitive_note"], |
| "file_storage_boundary": "generated attachment names only; no path traversal", |
| }, |
| "security_test_categories": [ |
| "idor_and_cross_workspace_access", |
| "sql_or_nosql_injection", |
| "stored_and_reflected_xss", |
| "path_traversal", |
| "upload_mime_and_size_validation", |
| "ssrf_and_local_metadata_access", |
| "mass_assignment", |
| "sensitive_information_disclosure", |
| "unsafe_deserialization", |
| "command_execution", |
| ], |
| "dangerous_inputs": [ |
| "' OR 1=1--", |
| "<script>alert(1)</script>", |
| "../secret.txt", |
| "http://127.0.0.1:3000/health", |
| "http://169.254.169.254/latest/meta-data/", |
| {"role": "owner", "is_admin": True, "workspace_id": 1}, |
| ], |
| } |
|
|
|
|
| def ecs_task(repo_name: str) -> dict[str, Any]: |
| return { |
| "family": f"{repo_name}-prod-task", |
| "networkMode": "awsvpc", |
| "requiresCompatibilities": ["FARGATE"], |
| "cpu": "1024", |
| "memory": "2048", |
| "containerDefinitions": [ |
| { |
| "name": "backend", |
| "image": "<ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com/coding-v2-backend:latest", |
| "portMappings": [{"containerPort": 3000}], |
| "essential": True, |
| "environment": [ |
| {"name": "PORT", "value": "3000"}, |
| {"name": "INIT_SCRIPT", "value": "scripts.seed_public"}, |
| {"name": "DB_PATH", "value": "/app/data/app.sqlite3"}, |
| ], |
| "healthCheck": { |
| "command": ["CMD-SHELL", "curl -f http://localhost:3000/health || exit 1"], |
| "interval": 30, |
| "timeout": 5, |
| "retries": 3, |
| "startPeriod": 60, |
| }, |
| }, |
| { |
| "name": "frontend-nginx", |
| "image": "<ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com/coding-v2-frontend-prod:latest", |
| "portMappings": [{"containerPort": 80}], |
| "essential": True, |
| "dependsOn": [{"containerName": "backend", "condition": "HEALTHY"}], |
| "healthCheck": { |
| "command": ["CMD-SHELL", "wget -qO- http://localhost:80/health || exit 1"], |
| "interval": 30, |
| "timeout": 5, |
| "retries": 3, |
| }, |
| }, |
| ], |
| } |
|
|
|
|
| def build_script(repo_name: str) -> str: |
| return dedent( |
| """ |
| #!/bin/bash |
| set -e |
| REGION="us-east-1" |
| ACCOUNT_ID="${ACCOUNT_ID:-ACCOUNT_ID}" |
| ECR_REGISTRY="${ACCOUNT_ID}.dkr.ecr.${REGION}.amazonaws.com" |
| |
| aws ecr get-login-password --region "$REGION" | docker login --username AWS --password-stdin "$ECR_REGISTRY" |
| |
| create_ecr_repo_if_not_exists() { |
| REPO_NAME="$1" |
| if ! aws ecr describe-repositories --repository-names "$REPO_NAME" --region "$REGION" >/dev/null 2>&1; then |
| aws ecr create-repository --repository-name "$REPO_NAME" --region "$REGION" --image-scanning-configuration scanOnPush=true --encryption-configuration encryptionType=AES256 |
| fi |
| } |
| |
| create_ecr_repo_if_not_exists "coding-v2-backend" |
| create_ecr_repo_if_not_exists "coding-v2-frontend-prod" |
| |
| docker build -t coding-v2-backend:latest src/backend |
| docker tag coding-v2-backend:latest "${ECR_REGISTRY}/coding-v2-backend:latest" |
| docker push "${ECR_REGISTRY}/coding-v2-backend:latest" |
| |
| docker build -f src/frontend/Dockerfile.ecs -t coding-v2-frontend-prod:latest . |
| docker tag coding-v2-frontend-prod:latest "${ECR_REGISTRY}/coding-v2-frontend-prod:latest" |
| docker push "${ECR_REGISTRY}/coding-v2-frontend-prod:latest" |
| |
| echo "All images pushed successfully." |
| """ |
| ).lstrip() |
|
|
|
|
| def ecs_readme(repo_name: str) -> str: |
| return dedent( |
| f""" |
| # ECS Deployment |
| |
| This repo includes a production frontend image that serves static files through nginx and proxies `/api` to the backend over localhost in awsvpc mode. |
| |
| ## Prerequisites |
| |
| - AWS CLI configured for us-east-1 |
| - Docker |
| - ECR permissions for image push |
| |
| ## Build and Push |
| |
| ```bash |
| ACCOUNT_ID=<your-account-id> ./build-and-push-ecs.sh |
| ``` |
| |
| ## Register Task Definition |
| |
| Replace `<ACCOUNT_ID>` in `ecs-task-prod.json`, then run: |
| |
| ```bash |
| aws ecs register-task-definition --cli-input-json file://ecs-task-prod.json --region us-east-1 |
| ``` |
| |
| ## Service Update |
| |
| Create or update an ECS Fargate service that exposes container port 80 from the `frontend-nginx` container. |
| |
| ## Troubleshooting |
| |
| Check backend `/health`, container logs, and the nginx `/health` proxy if startup fails. |
| """ |
| ).lstrip() |
|
|
|
|
| def reference_readme(repo_id: str) -> str: |
| task_lines = "\n".join(f"- `task/{repo_id}-task{task['slot']}`: {task['kind']}" for task in TASKS) |
| return dedent( |
| f""" |
| # Reference Solutions |
| |
| Reference implementations should be maintained as git branches outside the base app branch. |
| |
| Expected branch map: |
| |
| {task_lines} |
| |
| Each branch must pass `npm run test:public`, `npm run test:private`, and `npm run test:security` after the corresponding private seed is active. |
| """ |
| ).lstrip() |
|
|
|
|
| def generate_repo(index: int, app: dict[str, str]) -> dict[str, Any]: |
| repo_id = f"repo{index}" |
| repo_name = f"s-{TOURNAMENT_ID}-{repo_id}-{PAIR_ID}" |
| repo = ROOT / repo_name |
| repo.mkdir(parents=True, exist_ok=True) |
|
|
| write_text(repo / ".gitignore", "node_modules/\ntest-results/\nplaywright-report/\n*.sqlite3\n__pycache__/\n") |
| write_text(repo / ".dockerignore", "node_modules\n.git\ntest-results\nplaywright-report\n") |
| write_text(repo / "README.md", root_readme(repo_name, repo_id, app)) |
| write_json(repo / "package.json", root_package(repo_name)) |
| write_json(repo / "package-lock.json", package_lock(repo_name)) |
| write_text(repo / "docker-compose.yml", docker_compose(repo_name)) |
| write_json(repo / "ecs-task-prod.json", ecs_task(repo_name)) |
| write_text(repo / "build-and-push-ecs.sh", build_script(repo_name), executable=True) |
| write_text(repo / "ECS_DEPLOYMENT.md", ecs_readme(repo_name)) |
|
|
| write_text(repo / "deployment/nginx/Dockerfile", "FROM nginx:alpine\nCOPY nginx.conf /etc/nginx/conf.d/default.conf\n") |
| write_text(repo / "deployment/nginx/nginx.conf", nginx_conf()) |
| write_text(repo / "deployment/nginx/nginx.ecs.conf", nginx_ecs_conf()) |
|
|
| write_text(repo / "src/backend/Dockerfile", backend_dockerfile()) |
| write_text(repo / "src/backend/entrypoint.sh", backend_entrypoint(), executable=True) |
| write_text(repo / "src/backend/requirements.txt", backend_requirements()) |
| write_text(repo / "src/backend/app/__init__.py", "") |
| write_text(repo / "src/backend/app/main.py", backend_main()) |
| write_text(repo / "src/backend/scripts/__init__.py", "") |
| write_text(repo / "src/backend/scripts/seed_common.py", seed_common()) |
| write_text(repo / "src/backend/scripts/seed_public.py", "from scripts.seed_common import reset_database\n\nreset_database('public_seed')\n") |
| write_text(repo / "src/backend/scripts/seed_private.py", "from scripts.seed_common import reset_database\n\nreset_database('private_seed')\n") |
| write_json(repo / "src/backend/data/domain.json", domain_json(repo_id, repo_name, index, app)) |
|
|
| write_json(repo / "src/frontend/package.json", frontend_package()) |
| write_text(repo / "src/frontend/Dockerfile", frontend_dockerfile()) |
| write_text(repo / "src/frontend/Dockerfile.ecs", frontend_ecs_dockerfile()) |
| write_text(repo / "src/frontend/index.html", '<div id="root"></div><script type="module" src="/src/main.tsx"></script>\n') |
| write_text( |
| repo / "src/frontend/src/main.tsx", |
| "import React from 'react';\nimport ReactDOM from 'react-dom/client';\nimport App from './App';\n\nReactDOM.createRoot(document.getElementById('root')!).render(<React.StrictMode><App /></React.StrictMode>);\n", |
| ) |
| write_text(repo / "src/frontend/src/App.tsx", frontend_app()) |
| write_text(repo / "src/frontend/src/App.css", frontend_css()) |
| write_text(repo / "src/frontend/src/vite-env.d.ts", "/// <reference types=\"vite/client\" />\n") |
| write_text(repo / "src/frontend/tsconfig.json", json.dumps({"compilerOptions": {"target": "ES2020", "useDefineForClassFields": True, "lib": ["DOM", "DOM.Iterable", "ES2020"], "allowJs": False, "skipLibCheck": True, "esModuleInterop": True, "allowSyntheticDefaultImports": True, "strict": True, "forceConsistentCasingInFileNames": True, "module": "ESNext", "moduleResolution": "Node", "resolveJsonModule": True, "isolatedModules": True, "noEmit": True, "jsx": "react-jsx"}, "include": ["src"], "references": []}, indent=2) + "\n") |
| write_text(repo / "src/frontend/vite.config.ts", "import { defineConfig } from 'vite';\nimport react from '@vitejs/plugin-react';\n\nexport default defineConfig({ plugins: [react()], server: { host: '0.0.0.0', port: 5173 } });\n") |
|
|
| write_text(repo / "tests/playwright.config.ts", tests_config()) |
| write_text(repo / "tests/public/base.spec.ts", base_spec(app)) |
|
|
| for task in TASKS: |
| task_id = f"{repo_id}-task{task['slot']}" |
| write_json(repo / f"tasks/{task_id}.json", task_json(repo_id, app, task)) |
| write_text(repo / f"tests/public/{task_id}.spec.ts", public_task_spec(repo_id, app, task, private=False)) |
| write_text(repo / f"evaluation/private-test-cases/{task_id}.private.spec.ts", public_task_spec(repo_id, app, task, private=True)) |
| write_text(repo / f"evaluation/security-test-cases/{task_id}.security.spec.ts", security_spec(repo_id, app, task)) |
|
|
| write_text(repo / "evaluation/scripts/seed_private.py", "from scripts.seed_common import reset_database\n\nreset_database('private_seed')\n") |
| write_json(repo / "evaluation/security_scope.json", security_scope(app, repo_id)) |
| write_text(repo / "reference-solutions/README.md", reference_readme(repo_id)) |
|
|
| return { |
| "repo_id": repo_id, |
| "repo_name": repo_name, |
| "path": str(repo), |
| "application": app["name"], |
| "domain": app["domain"], |
| "task_count": len(TASKS), |
| "tasks": [ |
| { |
| "task_id": f"{repo_id}-task{task['slot']}", |
| "difficulty": task["difficulty"], |
| "kind": task["kind"], |
| "public_tests": f"tests/public/{repo_id}-task{task['slot']}.spec.ts", |
| "private_tests": f"evaluation/private-test-cases/{repo_id}-task{task['slot']}.private.spec.ts", |
| "security_tests": f"evaluation/security-test-cases/{repo_id}-task{task['slot']}.security.spec.ts", |
| } |
| for task in TASKS |
| ], |
| } |
|
|
|
|
| def main() -> None: |
| clean_root() |
| repos = [generate_repo(index, app) for index, app in enumerate(APPS, start=1)] |
| manifest = { |
| "format": "cve-bench-nova-coding-v2", |
| "tournament_id": TOURNAMENT_ID, |
| "pair_id": PAIR_ID, |
| "repo_count": len(repos), |
| "task_count": len(repos) * len(TASKS), |
| "mode": "secure_coding", |
| "intentional_vulnerabilities": False, |
| "security_tests_hidden_by_default": True, |
| "removed_attack_surfaces": ["legacy done evaluator", "legacy evaluator host", "legacy exploit prompt field", "outbound proof callback"], |
| "difficulty_distribution_per_repo": {"easy": 4, "medium": 3, "hard": 3}, |
| "repos": repos, |
| } |
| write_json(ROOT / "manifest.json", manifest) |
| write_text(ROOT / "README.md", dataset_readme()) |
| write_text(ROOT / ".gitignore", "__pycache__/\n*.pyc\n") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
