Describe an app, get a live URL

export OPENAI_API_KEY=sk-... APPS_DOMAIN=yourapps.dev
python 04_coding_agents/prompt_to_deployed_app.py

import hashlib
import json
import os
import re
from datetime import datetime, timezone

import noclick

APPS_DOMAIN = os.environ["APPS_DOMAIN"]
SPEND_CAP_USD = 25     # per user a month: sandboxes, builds, and what their apps spend
APP_BUDGET_USD = 10    # per app a month: its hosting, data, email and AI
CHANGES_PER_DAY = 40   # per user: each change is a Codex turn on your OpenAI key
FIX_ATTEMPTS = 2       # times a failed build goes back to the agent before we give up
PAYMENTS_COUNTRY = "US"  # where your users' businesses are: a payments account stays in its country

noclick.Domain.set_default_registrant(noclick.DomainContact(
    name="Dana Reyes", email="dana@yourco.test", phone="+14155550188", address="1 Ferry Building",
    city="San Francisco", region="CA", postal_code="94111", country="US",
    agreement_accepted_at=accepted_at,   # when Dana accepted the agreement
))

MAX_DOMAIN_PRICE_USD = 20


def apps_domain() -> noclick.Domain:
    try:
        domain = noclick.Domain.from_name(
            APPS_DOMAIN, create_if_missing=True, max_price_usd=MAX_DOMAIN_PRICE_USD,
        ).hydrate()
    except noclick.ActionRequired as err:
        raise SystemExit(f"{err.message}\n{err.next_step}") from None
    if domain.source != "bought" and not domain.wildcard:
        raise SystemExit(f"Connect {APPS_DOMAIN} with noclick.Domain.connect(..., wildcard=True) first.")
    return domain

def house_openai() -> noclick.Connection:
    return noclick.Connection.from_name(
        "openai", integration="openai", data={"api_key": os.environ["OPENAI_API_KEY"]}, create_if_missing=True,
    )

def builder_instructions(slug: str, host: str, processor: str) -> str:
    return f"""You build and change one web app for the person you're talking to. It's live at
https://{host}.

The code is a Next.js app (App Router, TypeScript) in /workspace/{slug}, a checkout of the app's
repository. The first message describes the app; later ones ask for changes. For each:

1. Make the change. Keep the app small and plain: no extra services, no background workers.
2. Run `npm run build` and fix every error.
3. Commit and push to main. Pushing is what ships: after your turn, the platform sets up the
   services the app declares, applies new migrations, and deploys main.

Declare what the app needs in services.json at the repository root, and only what it needs:
{{"database": true, "email": true, "payments": true, "secrets": ["WEATHER_API_KEY"]}}

- database: a SQL database (SQLite). In server code, `import {{ Project }} from "noclick"`, then
  `const db = await Project.current().database("DB")`: `await db.query(sql, params)` reads and
  `await db.execute(sql, params)` writes, with `?` placeholders. Keep the schema in
  migrations/NNNN_name.sql, one new file per change, and never edit one you've pushed. Migrations
  run before the new code goes live, so only add tables and columns.
- email: transactional email from the app's own address, with
  `await Project.current().email.send({{ to, subject, text, html, idempotencyKey }})`. Receipts,
  confirmations and sign-in codes only, never marketing.
- payments: a payments account the app's owner will own, at {processor}: take payments with the
  `{processor}` npm package. Its keys are in PAYMENTS_SECRET_KEY, PAYMENTS_PUBLISHABLE_KEY and
  PAYMENTS_WEBHOOK_SECRET. It runs in test mode until the owner claims it, so never hardcode a key
  or assume live mode.
- secrets: the names of other API keys the app reads from process.env. Never put a key in code;
  the person adds each one themselves.

AI needs no declaration: in server code, `const reply = await Project.current().ai.chat(prompt)`
calls a model, and `reply.text` is its answer.

Use the database, email, AI and payment keys from server code only, never in the browser.

The app has a monthly budget. Once it's used up, the app keeps serving pages and reading its data,
but database writes, email and AI calls throw `SpendCapExceeded` (or `PaymentRequired`), both
exported by "noclick". Catch them where you make those calls and keep the page working: show it
without the AI part, or tell the visitor to try again later. Never let one become an error page.

Reply in two or three plain sentences for the person: what changed, and anything they need to do.
Don't paste code."""

def user_for(user_id: str) -> noclick.User:
    return noclick.User.from_id(user_id, create_if_missing=True, spend_cap_usd_per_month=SPEND_CAP_USD)


def slugify(name: str) -> str:
    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:24] or "app"


def host_for(user_id: str, slug: str) -> str:
    return f"{slug}-{hashlib.sha256(user_id.encode()).hexdigest()[:6]}.{APPS_DOMAIN}"


def open_app(user_id: str, name: str) -> str:
    slug = slugify(name)
    host = host_for(user_id, slug)
    with noclick.as_user(user_for(user_id)):
        repo = noclick.Repo.from_name(slug, create_if_missing=True)
        app = noclick.Project.from_name(
            slug, repo=repo, framework="nextjs", budget_usd_per_month=APP_BUDGET_USD, create_if_missing=True,
        )
        if host not in app.domain_names:
            app.add_domain(host)
    return slug


def builder_for(slug: str, host: str, openai: noclick.Connection) -> noclick.Agent:
    repo = noclick.Repo.from_name(slug)
    processor = noclick.Project.from_name(slug).payments.status().processor
    return noclick.Agent.from_name(
        f"builder-{slug}",
        create_if_missing=True,
        harness="codex",
        model_connection=openai,
        instructions=builder_instructions(slug, host, processor),
        repos=[repo.checkout(push=["main"])],
        budget_usd_per_month=10,
    )

def read_services(repo: noclick.Repo) -> dict:
    try:
        return json.loads(repo.read("services.json"))
    except noclick.NotFound:
        return {}


def apply_migrations(repo: noclick.Repo, data: noclick.Database) -> None:
    try:
        entries = repo.files("migrations/")
    except noclick.NotFound:
        return
    migrations = {
        entry.path.rsplit("/", 1)[-1]: repo.read(entry.path).decode()
        for entry in entries
        if entry.type == "file" and entry.path.endswith(".sql")
    }
    if migrations:
        data.migrate(migrations)


def provision(slug: str, host: str) -> list[str]:
    repo = noclick.Repo.from_name(slug)
    app = noclick.Project.from_name(slug)
    services = read_services(repo)
    notes = []
    if services.get("database"):
        data = noclick.Database.from_name(f"{slug}-data", create_if_missing=True)
        app.bind("DB", data)
        apply_migrations(repo, data)
    if services.get("email"):
        app.email.enable(domain=host)
    if services.get("payments"):
        payments = app.payments.enable(country=PAYMENTS_COUNTRY)
        if payments.mode == "test":
            notes.append(f"Payments take test cards for now. To take real money, claim the account: {payments.claim_url}")
    missing = sorted(set(services.get("secrets", [])) - set(app.secrets.list()))
    if missing:
        notes.append("The app needs " + ", ".join(missing) + ". Add each with /secret NAME value.")
    return notes

class BuildFailed(Exception):
    pass


def ship(slug: str, host: str, builder: noclick.Agent) -> list[str]:
    attempts = 0
    while True:
        try:
            notes = provision(slug, host)
            noclick.Project.from_name(slug).deploy().wait()
            return notes
        except noclick.OperationFailed as failed:
            broken = noclick.Deployment.get(failed.deployment_id)
            problem = "The build failed. The end of its log:\n" + "\n".join(
                line.message for line in broken.logs(kind="build")[-80:]
            )
        except noclick.InvalidRequest as failed:
            problem = f"Setting up the app failed: {failed.message}"
        attempts += 1
        if attempts > FIX_ATTEMPTS:
            raise BuildFailed(problem)
        builder.message(f"{problem}\n\nFix it, then commit and push.", conversation="build")

def within_daily_limit(user_id: str) -> bool:
    changes = noclick.Dict.from_name("app-builder-changes", create_if_missing=True)
    today = datetime.now(timezone.utc).date().isoformat()
    return changes.increment(f"{user_id}:{today}", ttl_s=2 * 86400) <= CHANGES_PER_DAY


def head(repo: noclick.Repo) -> str | None:
    last = repo.refresh().last_commit
    return last.sha if last else None


def change(user_id: str, slug: str, text: str, openai: noclick.Connection) -> str:
    if not within_daily_limit(user_id):
        return f"That's {CHANGES_PER_DAY} changes today. Try again tomorrow."
    host = host_for(user_id, slug)
    with noclick.as_user(user_for(user_id)):
        repo = noclick.Repo.from_name(slug)
        builder = builder_for(slug, host, openai)
        try:
            before = head(repo)
            reply = builder.message(text, conversation="build")
            if head(repo) == before:
                return reply.text
            notes = ship(slug, host, builder)
        except noclick.SpendCapExceeded:
            return "You've reached this month's limit for your apps."
        except BuildFailed as failed:
            return f"That change didn't build, so the live app is unchanged.\n{failed}"
        spent = noclick.usage().total_usd
    lines = [reply.text, f"Live at https://{host}", *notes, f"This month: ${spent:.2f} of ${SPEND_CAP_USD}"]
    return "\n".join(lines)


def set_secret(user_id: str, slug: str, command: str) -> str:
    parts = command.split(maxsplit=2)
    if len(parts) != 3:
        return "Use /secret NAME value"
    _, name, value = parts
    with noclick.as_user(user_for(user_id)):
        app = noclick.Project.from_name(slug)
        app.secrets.set(name, value)
        app.deploy().wait()
    return f"{name} is set and the app has been redeployed with it."

def main() -> None:
    apps_domain()
    openai = house_openai()
    user_id = "user_42"
    slug = open_app(user_id, input("Name your app: "))
    print(f"Describe it, then ask for changes. It will live at https://{host_for(user_id, slug)}")
    while text := input("> ").strip():
        if text.startswith("/secret "):
            print(set_secret(user_id, slug, text))
        else:
            print(change(user_id, slug, text, openai))


if __name__ == "__main__":
    main()

with noclick.as_user("user_42"):
    noclick.Agent.from_name("builder-yoga-classes").delete()
    noclick.Project.from_name("yoga-classes").delete(delete_data=True)