### Install Frost using curl and bash

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/installation/page.mdx

This snippet downloads and executes the Frost installation script from a remote URL using curl and bash. Ensure you have sudo privileges to run the script.

```bash
curl -fsSL https://raw.githubusercontent.com/elitan/frost/main/install.sh | sudo bash
```

--------------------------------

### Frost Configuration Example (YAML)

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/config-file/page.mdx

An example of the frost.yaml file structure, demonstrating how to define Dockerfile, port, health check, and resource allocation for a service.

```yaml
# frost.yaml
dockerfile: Dockerfile
port: 3000
health_check:
  path: /health
  timeout: 30
resources:
  memory: 512m
  cpu: 0.5
```

--------------------------------

### Run Frost Development Server (Bun)

Source: https://github.com/elitan/frost/blob/main/README.md

This code snippet demonstrates the commands to install project dependencies and start the Frost development server using Bun. It assumes the project is set up with Bun as the package manager and runtime.

```bash
bun install
bun run dev
```

--------------------------------

### Basic Dockerfile for Frost Deployment

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

A foundational Dockerfile structure for deploying applications on Frost. It emphasizes multi-stage builds, copying only necessary files, and setting the CMD to start the application.

```dockerfile
# Example Dockerfile structure
# Use multi-stage builds for smaller images

# Build stage
FROM node:18-alpine as builder
WORKDIR /app
COPY package*.json ./ 
RUN npm install
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
COPY package.json ./

# Expose the port Frost will use (e.g., 8080)
EXPOSE 8080

# Command to run the application, ensuring it listens on the PORT env var
CMD ["node", "dist/server.js"]
```

--------------------------------

### Install Frost using cURL (Bash)

Source: https://github.com/elitan/frost/blob/main/README.md

This snippet shows how to install Frost on your server by downloading and executing an installation script using cURL and piping it to bash. It requires root privileges to run the script.

```bash
curl -fsSL https://frost.build/install.sh | sudo bash
```

--------------------------------

### Port Configuration Example

Source: https://context7.com/elitan/frost/llms.txt

This snippet shows how to configure the port on which the application will listen. Frost uses this information to expose the service correctly.

```yaml
port: 3000
```

--------------------------------

### Install Frost Deployment Platform via SSH

Source: https://github.com/elitan/frost/blob/main/INSTALL.md

This snippet demonstrates how to remotely execute the Frost installation script on a newly provisioned server using SSH. It fetches the script from a GitHub URL and pipes it to bash for execution with sudo privileges. Ensure SSH connectivity is established before running.

```bash
ssh -o StrictHostKeyChecking=no root@{server_ip} \
  "curl -fsSL https://raw.githubusercontent.com/elitan/frost/main/install.sh | sudo bash"
```

--------------------------------

### Dockerfile Configuration Example

Source: https://context7.com/elitan/frost/llms.txt

This snippet demonstrates a basic Dockerfile configuration for the Frost deployment. It specifies the Dockerfile to be used for building the application image.

```yaml
dockerfile: Dockerfile
```

--------------------------------

### Frost Template YAML Configuration Example

Source: https://github.com/elitan/frost/blob/main/apps/app/templates/README.md

Provides an example of the YAML format used for defining Frost templates, including service metadata, Docker image, ports, environment variables, volumes, and health checks.

```yaml
name: Service Name
description: Short description
category: database|webserver|testing|analytics|etc
docs: https://link-to-documentation

services:
  service-name:
    image: docker/image:tag
    port: 8080                    # container port
    main: true                    # (projects only) gets domain, shown first
    type: database                # optional: marks as database service
    command: /bin/sh -c "..."     # optional: custom startup command
    environment:
      STATIC_VAR: value
      GENERATED_VAR:
        generated: password       # auto-generate credential
      CROSS_REF: ${other.VAR}     # reference other service's env var
    volumes:
      - data:/path/in/container   # named volume
    health_check:
      path: /health               # optional: HTTP health check path
      timeout: 60                 # seconds to wait for healthy
    ssl: true                     # optional: generate self-signed cert (databases)
```

--------------------------------

### Monorepo Dockerfile Path in frost.yaml

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

Demonstrates how to specify a Dockerfile located in a subdirectory for monorepo setups within the frost.yaml configuration.

```yaml
dockerfile: apps/web/Dockerfile
```

--------------------------------

### Local Docker Build and Run Verification

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

Commands to locally build a Docker image and run a container, simulating the Frost deployment environment by setting the PORT environment variable.

```bash
# Build the image
docker build -t my-app .

# Run with PORT env var (same as Frost does)
docker run -p 8080:8080 -e PORT=8080 my-app

# Test it responds
curl http://localhost:8080

# If you configured a health check path:
curl http://localhost:8080/health
```

--------------------------------

### Local Testing API Interactions (Bash)

Source: https://github.com/elitan/frost/blob/main/CLAUDE.md

Example `curl` commands for interacting with the Frost API locally to create projects, deploy services, and check deployment status.

```bash
# create project using local fixture
curl -X POST localhost:3000/api/projects \
  -H "Content-Type: application/json" \
  -d '{"name":"test","repo_url":"./test/fixtures/simple-node","port":3000}'

# deploy
curl -X POST localhost:3000/api/projects/{id}/deploy

# check status
curl localhost:3000/api/deployments/{id}
```

--------------------------------

### Resource Allocation Example

Source: https://context7.com/elitan/frost/llms.txt

This snippet specifies the memory and CPU resources allocated to the deployed service. Frost uses these settings to manage resource provisioning.

```yaml
resources:
  memory: 512m
  cpu: 1.0
```

--------------------------------

### frost.yaml Configuration File Structure

Source: https://context7.com/elitan/frost/llms.txt

Example of the `frost.yaml` file used for configuring service builds. This file should be placed in the root of your repository.

```yaml
# frost.yaml
```

--------------------------------

### Build and Run Frost Marketing Locally with Docker

Source: https://github.com/elitan/frost/blob/main/apps/marketing/README.md

This snippet demonstrates how to build the Docker image for the Frost marketing site and run it as a container locally. It requires Docker to be installed and configured on your system. The build command uses the specified Dockerfile and context, while the run command maps the container port to the host port.

```bash
docker build -f apps/marketing/Dockerfile -t frost-marketing .
docker run -p 3000:3000 frost-marketing
```

--------------------------------

### Get Deployment Details (API)

Source: https://context7.com/elitan/frost/llms.txt

Retrieves detailed information about a specific deployment, including its status, commit details, and timestamps.

```bash
curl -X GET http://localhost:3000/api/deployments/dep_abc789 \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Get Service Details (API)

Source: https://context7.com/elitan/frost/llms.txt

Retrieves details of a specific service, including its latest deployment information.

```bash
curl -X GET http://localhost:3000/api/services/svc_123 \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Settings API

Source: https://context7.com/elitan/frost/llms.txt

Endpoints for managing global platform settings, including SSL configuration, GitHub App integration, and wildcard domain setup.

```APIDOC
## GET /api/settings

### Description
Retrieves the current global platform settings.

### Method
GET

### Endpoint
/api/settings

### Request Example
```bash
curl -X GET http://localhost:3000/api/settings \
  -H "Authorization: Bearer <api-key>"
```

### Response
#### Success Response (200)
- **domain** (string) - The configured domain.
- **email** (string) - The administrator email.
- **sslEnabled** (string) - Indicates if SSL is enabled.
- **serverIp** (string) - The server IP address.

#### Response Example
```json
{"domain": "frost.myserver.com", "email": "admin@example.com", "sslEnabled": "true", "serverIp": "1.2.3.4"}
```

## POST /api/settings/verify-dns

### Description
Verifies the DNS configuration for the root domain.

### Method
POST

### Endpoint
/api/settings/verify-dns

### Parameters
#### Request Body
- **domain** (string) - Required - The root domain to verify.

### Request Example
```bash
curl -X POST http://localhost:3000/api/settings/verify-dns \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{"domain": "frost.myserver.com"}'
```

## POST /api/settings/enable-ssl

### Description
Enables SSL with Let's Encrypt for a specified domain.

### Method
POST

### Endpoint
/api/settings/enable-ssl

### Parameters
#### Request Body
- **domain** (string) - Required - The domain for which to enable SSL.
- **email** (string) - Required - The email address for certificate notifications.
- **staging** (boolean) - Required - Whether to use the Let's Encrypt staging environment.

### Request Example
```bash
curl -X POST http://localhost:3000/api/settings/enable-ssl \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{ "domain": "frost.myserver.com", "email": "admin@example.com", "staging": false }'
```

## GET /api/settings/github

### Description
Retrieves the GitHub App settings.

### Method
GET

### Endpoint
/api/settings/github

### Request Example
```bash
curl -X GET http://localhost:3000/api/settings/github \
  -H "Authorization: Bearer <api-key>"
```

### Response
#### Success Response (200)
- **hasDomain** (boolean) - Indicates if a domain is configured for GitHub integration.
- **connected** (boolean) - Indicates if the GitHub App is connected.
- **installed** (boolean) - Indicates if the GitHub App is installed.
- **appName** (string) - The name of the GitHub App.
- **installations** (array) - A list of GitHub App installations.
  - **id** (integer) - The installation ID.
  - **accountLogin** (string) - The login name of the account.
  - **accountType** (string) - The type of the account (e.g., Organization, User).

#### Response Example
```json
{
  "hasDomain": true,
  "connected": true,
  "installed": true,
  "appName": "My Frost App",
  "installations": [
    {"id": 12345, "accountLogin": "myorg", "accountType": "Organization"}
  ]
}
```

## POST /api/settings/wildcard

### Description
Configures a wildcard domain for automatic subdomain routing.

### Method
POST

### Endpoint
/api/settings/wildcard

### Parameters
#### Request Body
- **wildcardDomain** (string) - Required - The wildcard domain (e.g., "*.apps.myserver.com").
- **dnsProvider** (string) - Required - The DNS provider (e.g., "cloudflare").
- **dnsApiToken** (string) - Required - The API token for the DNS provider.

### Request Example
```bash
curl -X POST http://localhost:3000/api/settings/wildcard \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{ "wildcardDomain": "*.apps.myserver.com", "dnsProvider": "cloudflare", "dnsApiToken": "cf_token_xxx" }'
```

## POST /api/settings/wildcard/test

### Description
Tests the credentials for the configured DNS provider.

### Method
POST

### Endpoint
/api/settings/wildcard/test

### Parameters
#### Request Body
- **dnsProvider** (string) - Required - The DNS provider (e.g., "cloudflare").
- **dnsApiToken** (string) - Required - The API token for the DNS provider.

### Request Example
```bash
curl -X POST http://localhost:3000/api/settings/wildcard/test \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{ "dnsProvider": "cloudflare", "dnsApiToken": "cf_token_xxx" }'
```
```

--------------------------------

### Common .dockerignore File

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

A sample .dockerignore file to exclude unnecessary files and directories from the Docker build context, leading to smaller image sizes and faster builds.

```dockerignore
node_modules
.git
.env
.env.*
dist
build
.next
*.md
.DS_Store
```

--------------------------------

### Manage Cleanup Settings (Get, Update, Trigger, Status)

Source: https://context7.com/elitan/frost/llms.txt

API endpoints for configuring and managing automated cleanup of old deployments and Docker images. Allows retrieving current settings, updating them, manually triggering a cleanup, and checking the status of the cleanup process. Requires an API key for authentication.

```bash
# Get cleanup settings
curl -X GET http://localhost:3000/api/cleanup \
  -H "Authorization: Bearer <api-key>"

# Response:
# {
#   "enabled": true,
#   "schedule": "0 3 * * *",
#   "retentionDays": 7,
#   "running": false,
#   "lastRun": "2024-01-15T03:00:00.000Z",
#   "lastResult": "Cleaned 15 deployments, freed 2.3GB"
# }

# Update cleanup settings
curl -X POST http://localhost:3000/api/cleanup \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "enabled": true,
    "schedule": "0 4 * * *",
    "retentionDays": 14
  }'

# Manually trigger cleanup
curl -X POST http://localhost:3000/api/cleanup/run \
  -H "Authorization: Bearer <api-key>"

# Check cleanup status
curl -X GET http://localhost:3000/api/cleanup/run \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Correct Network Binding in Server Listen (Bash)

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

Ensures the application server listens on all network interfaces (0.0.0.0) instead of just localhost. This is crucial for containerized applications to be reachable from outside the container. The code snippet demonstrates the correct way to configure the server to listen on 0.0.0.0.

```Bash
# Wrong
server.listen(PORT, "localhost")

# Correct
server.listen(PORT, "0.0.0.0")
```

--------------------------------

### Node.js Server Listening on Dynamic Port

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

Ensures a Node.js application listens on the port specified by the PORT environment variable, with a fallback to 8080. This is crucial for compatibility with deployment platforms like Frost.

```javascript
server.listen(process.env.PORT || 8080)
```

--------------------------------

### List Project Templates (Full-Stack Starters)

Source: https://context7.com/elitan/frost/llms.txt

Retrieves a list of available full-stack project templates. Requires an API key for authentication.

```bash
curl -X GET http://localhost:3000/api/templates/projects \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Verify Frost Service Status

Source: https://github.com/elitan/frost/blob/main/INSTALL.md

This code snippet checks if the Frost service is running on the server by making an HTTP request to its default port (3000). It uses curl to retrieve the HTTP status code, which should be 302 (redirect to setup) or 200 (if setup is complete).

```bash
curl -s -o /dev/null -w "%{http_code}" http://{server_ip}:3000
```

--------------------------------

### List Project Templates

Source: https://context7.com/elitan/frost/llms.txt

Retrieves a list of available full-stack project templates (starters) for creating new projects.

```APIDOC
## GET /api/templates/projects

### Description
Lists all available full-stack project templates (starters).

### Method
GET

### Endpoint
/api/templates/projects

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```bash
curl -X GET http://localhost:3000/api/templates/projects \
  -H "Authorization: Bearer <api-key>"
```

### Response
#### Success Response (200)
- **templates** (array) - An array of project template objects.
  - **name** (string) - The name of the template.
  - **description** (string) - A brief description of the template.
  - **repository** (string) - The URL of the template's repository.

#### Response Example
```json
{
  "templates": [
    {
      "name": "Node.js Express",
      "description": "A starter template for Node.js with Express framework.",
      "repository": "https://github.com/frost/starter-nodejs-express"
    }
  ]
}
```
```

--------------------------------

### Inter-Service Communication Example

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/concepts/services/page.mdx

Demonstrates how to make HTTP requests between services within the same Frost project. Services are accessible using their defined name as the hostname. The default port is 8080, but this can be configured.

```text
http://api:8080/health
```

--------------------------------

### Get Service Volumes (API)

Source: https://context7.com/elitan/frost/llms.txt

Retrieves information about the volumes attached to a service, including their disk usage.

```bash
curl -X GET http://localhost:3000/api/services/svc_123/volumes \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Deploy Service (API)

Source: https://context7.com/elitan/frost/llms.txt

Initiates a deployment for a specific service.

```bash
curl -X POST http://localhost:3000/api/services/svc_123/deploy \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Manage Projects API (Bash)

Source: https://context7.com/elitan/frost/llms.txt

This snippet demonstrates how to interact with the Projects API using cURL. It covers listing, creating, retrieving, updating, deleting projects, and triggering deployments. Requires an API key for authentication.

```bash
# List all projects
curl -X GET http://localhost:3000/api/projects \
  -H "Authorization: Bearer <api-key>"

# Response:
# [
#   {
#     "id": "proj_abc123",
#     "name": "my-app",
#     "envVars": "[]",
#     "createdAt": 1704067200000,
#     "hostname": null,
#     "servicesCount": 2,
#     "latestDeployment": {
#       "status": "running",
#       "commitMessage": "feat: add login page",
#       "createdAt": 1704067200000,
#       "branch": "main"
#     },
#     "services": [
#       {"id": "svc_123", "name": "api", "deployType": "repo", "status": "running"},
#       {"id": "svc_456", "name": "web", "deployType": "repo", "status": "running"}
#     ]
#   }
# ]

# Create a new project
curl -X POST http://localhost:3000/api/projects \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{ \
    "name": "my-new-project", \
    "envVars": [ \
      {"key": "NODE_ENV", "value": "production"}, \
      {"key": "LOG_LEVEL", "value": "info"} \
    ] \
  }'

# Get a specific project with services
curl -X GET http://localhost:3000/api/projects/proj_abc123 \
  -H "Authorization: Bearer <api-key>"

# Update a project
curl -X PATCH http://localhost:3000/api/projects/proj_abc123 \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{ \
    "name": "renamed-project", \
    "envVars": [{"key": "DATABASE_URL", "value": "postgres://..."}] \
  }'

# Delete a project (stops all services and removes containers)
curl -X DELETE http://localhost:3000/api/projects/proj_abc123 \
  -H "Authorization: Bearer <api-key>"

# Deploy all services in a project
curl -X POST http://localhost:3000/api/projects/proj_abc123/deploy \
  -H "Authorization: Bearer <api-key>"
# Response: {"deploymentIds": ["dep_xyz789", "dep_xyz790"]}
```

--------------------------------

### Frost Generated Values Examples

Source: https://github.com/elitan/frost/blob/main/apps/app/templates/README.md

Demonstrates the use of the `generated` keyword in Frost templates to automatically create credentials like passwords and secrets.

```yaml
environment:
  GENERATED_VAR:
    generated: password       # auto-generate credential
  BASE64_SECRET:
    generated: base64_32      # 32-byte base64-encoded secret
```

--------------------------------

### Create Service from Git Repository (API)

Source: https://context7.com/elitan/frost/llms.txt

Creates a new service deployed from a Git repository. Requires repository URL, branch, and optionally Dockerfile path, environment variables, and resource limits.

```bash
curl -X POST http://localhost:3000/api/environments/env_prod/services \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "api-server",
    "deployType": "repo",
    "repoUrl": "https://github.com/myorg/myapp",
    "branch": "main",
    "dockerfilePath": "Dockerfile",
    "containerPort": 3000,
    "envVars": [
      {"key": "DATABASE_URL", "value": "postgres://db:5432/app"},
      {"key": "REDIS_HOST", "value": "redis"}
    ],
    "healthCheckPath": "/health",
    "healthCheckTimeout": 60,
    "memoryLimit": "512m",
    "cpuLimit": 1.0
  }'
```

--------------------------------

### Manage Environments API (Bash)

Source: https://context7.com/elitan/frost/llms.txt

This snippet shows how to manage environments within a project using cURL. It includes operations for listing, creating, retrieving, deploying, and deleting environments. Authentication is required via an API key.

```bash
# List environments for a project
curl -X GET http://localhost:3000/api/projects/proj_abc123/environments \
  -H "Authorization: Bearer <api-key>"

# Response:
# [
#   {"id": "env_prod", "projectId": "proj_abc123", "name": "production", "type": "production"},
#   {"id": "env_preview", "projectId": "proj_abc123", "name": "PR #42", "type": "preview", "prNumber": 42}
# ]

# Create a new environment (optionally clone from existing)
curl -X POST http://localhost:3000/api/projects/proj_abc123/environments \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{ \
    "name": "staging", \
    "type": "manual", \
    "cloneFromEnvironmentId": "env_prod" \
  }'

# Get environment with all services
curl -X GET http://localhost:3000/api/environments/env_prod \
  -H "Authorization: Bearer <api-key>"

# Deploy all services in an environment
curl -X POST http://localhost:3000/api/environments/env_prod/deploy \
  -H "Authorization: Bearer <api-key>"

# Delete an environment (cannot delete production)
curl -X DELETE http://localhost:3000/api/environments/env_staging \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Frost Cross-Service Reference Example

Source: https://github.com/elitan/frost/blob/main/apps/app/templates/README.md

Shows how to reference environment variables from one service within another service's configuration in Frost project templates.

```yaml
DATABASE_URL: postgres://user:${postgres.POSTGRES_PASSWORD}@postgres:5432/db
```

--------------------------------

### Create Multiple Services in Batch (API)

Source: https://context7.com/elitan/frost/llms.txt

Creates multiple services simultaneously from a single Git repository, useful for monorepos. Requires repository URL, branch, and a list of services with their respective Dockerfile paths and container ports.

```bash
curl -X POST http://localhost:3000/api/environments/env_prod/services/batch \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "repoUrl": "https://github.com/myorg/monorepo",
    "branch": "main",
    "services": [
      {"name": "api", "dockerfilePath": "apps/api/Dockerfile", "buildContext": ".", "containerPort": 3000},
      {"name": "web", "dockerfilePath": "apps/web/Dockerfile", "buildContext": ".", "containerPort": 8080}
    ]
  }'
```

--------------------------------

### Health Check Configuration Example

Source: https://context7.com/elitan/frost/llms.txt

This snippet defines the health check endpoint and timeout for the deployed service. Frost uses this to monitor the application's health.

```yaml
health_check:
  path: /health
  timeout: 60
```

--------------------------------

### HTTP Health Check Configuration

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

Configures Frost to perform HTTP health checks on a specified path with a given timeout. This is an alternative to the default TCP health check.

```yaml
health_check:
  path: /health
  timeout: 30
```

--------------------------------

### Create Service from Docker Image (API)

Source: https://context7.com/elitan/frost/llms.txt

Creates a new service deployed from a pre-built Docker image. Requires image URL and container port.

```bash
curl -X POST http://localhost:3000/api/environments/env_prod/services \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "redis",
    "deployType": "image",
    "imageUrl": "redis:7-alpine",
    "containerPort": 6379
  }'
```

--------------------------------

### frost.yaml Configuration for Frost Deployment

Source: https://github.com/elitan/frost/blob/main/apps/marketing/src/app/docs/guides/ai-setup/page.mdx

An optional frost.yaml file to configure deployment settings for Frost. It specifies the Dockerfile path, the port to listen on, and health check configurations.

```yaml
# yaml-language-server: $schema=https://raw.githubusercontent.com/elitan/frost/main/apps/app/frost.schema.json

dockerfile: Dockerfile
port: 8080
health_check:
  path: /health
  timeout: 30
```

--------------------------------

### Manage API Keys (List, Create, Delete)

Source: https://context7.com/elitan/frost/llms.txt

Endpoints for managing API keys to grant programmatic access to the Frost API. Includes functionality to list existing keys, create new ones with a specified name, and delete keys by their ID. Requires an API key for authentication.

```bash
# List API keys
curl -X GET http://localhost:3000/api/settings/api-keys \
  -H "Authorization: Bearer <api-key>"

# Response:
# [
#   {
#     "id": "key_abc123",
#     "name": "CI/CD Pipeline",
#     "keyPrefix": "frost_abc...",
#     "createdAt": "2024-01-01T00:00:00.000Z",
#     "lastUsedAt": "2024-01-15T12:00:00.000Z"
#   }
# ]

# Create a new API key
curl -X POST http://localhost:3000/api/settings/api-keys \
  -H "Authorization: Bearer <api-key>" \
  -H "Content-Type: application/json" \
  -d '{"name": "GitHub Actions"}'

# Response (key shown only once):
# {"id": "key_xyz789", "name": "GitHub Actions", "key": "frost_xyz789_secrettoken"}

# Delete an API key
curl -X DELETE http://localhost:3000/api/settings/api-keys/key_abc123 \
  -H "Authorization: Bearer <api-key>"
```

--------------------------------

### Frost CLI Commands (Bash)

Source: https://github.com/elitan/frost/blob/main/CLAUDE.md

Common command-line interface commands for the Frost platform, used for development and build processes.

```bash
bun run dev          # start dev server
bun run build        # production build
bun run db:gen       # regenerate db types (run after schema changes)
```

--------------------------------

### Stream Deployment Logs (API)

Source: https://context7.com/elitan/frost/llms.txt

Streams real-time logs for a specific deployment, useful for monitoring build output.

```bash
curl -X GET http://localhost:3000/api/deployments/dep_abc789/logs \
  -H "Authorization: Bearer <api-key>" \
  -H "Accept: text/event-stream"
```