Open-source deployment packages

From colors.yml to a running server.

Colors packages OpenTofu and Ansible into reproducible deployments you can inspect before they run. Your infrastructure stays in your cloud account, and your credentials stay local.

Installation
npx skills add getcolors/once
Try Once: provision a VPS, DNS, outgoing mail, Docker, HTTPS, and declared applications from one desired-state file.
# The real colors.yml that deploys this site
profile: once-colors
workdir: .colors

once:
  applications:
    - host: www.getcolors.ai
      image: ghcr.io/getcolors/colors-website:latest
      github: getcolors/colors-website

provider-compute: oci
provider-smtp: resend
provider-dns: cloudflare
provider-backend: r2
compute-prevent-destroy: true
Real-life example

The configuration shown above is not a mock-up: it deploys this website with the Once Package Skill, an implementation of Basecamp’s production single-server ONCE workflow. Starting with an OCI account and a domain, it creates the server and connects every layer needed to serve the application.

  • Provisions the VPS with OpenTofu
  • Configures Docker and the host with Ansible
  • Creates Cloudflare DNS and Resend mail settings
  • Serves the declared container over HTTPS

There is no Colors dashboard or long-running Colors control plane on the server. Once the workflow finishes, the VPS and provider resources remain yours.

Every deployment uses the same explicit lifecycle. The first two commands are safe on a fresh checkout with no provider credentials.

./green build

Render locally

Validate colors.yml and generate the OpenTofu, Ansible, and supporting files under .colors/.

./green create --dry-run

Walk the complete plan

Traverse the deployment graph while skipping every provider call and remote side effect.

./green create

Provision and verify

Converge the declared infrastructure, configure the hosts, and run the package’s acceptance checks.

You can. Colors is useful when you want a tested, opinionated path through them rather than assembling and maintaining every layer yourself.

Versus an install script

Desired state, not curl-to-shell

Inputs are validated, generated infrastructure is inspectable, repeated runs converge, and deletion follows an explicit guarded graph.

Versus raw IaC

A packaged operational path

A Package Skill bundles provider resources, host configuration, credential boundaries, ordering, and acceptance checks behind one lifecycle.

Versus a self-hosted PaaS

No permanent control panel

Colors provisions the infrastructure and exits. It can deploy a personal PaaS such as Once; it does not manage applications through a web dashboard.

Visible automation

OpenTofu and Ansible stay inspectable

build renders the files locally before create is allowed to contact a provider or host.

Local credentials

Secrets never belong in `colors.yml`

Credentials arrive through local COLORS_PAR_* environment variables and are not rendered into generated files.

Deterministic execution

No model provisions your server

A coding agent can install and operate a Package Skill, but the launcher itself is ordinary deterministic code and makes no LLM calls.

Honest fit

Not for every self-hoster

If you want a dashboard for an existing homelab, or already prefer maintaining all your IaC directly, Colors may add no value.

Colors is an SDK made of three interchangeable libraries for building Package Skills. Pick the runtime your team already uses — the guarantees don't change: dry-run boundaries, secret indirection, identical desired-state semantics.

red

TypeScript / Bun

Build Package Skills with a fast TypeScript/Bun runtime.

green

Clojure / Babashka

Build Package Skills with Clojure over Babashka.

blue

Python / uv

Build Package Skills with Python, managed by uv.

A Package Skill provisions infrastructure; a Context Skill remembers what a verified build learned. Each kind can be created with your agent, and each can be submitted to the Skills Catalog — four workflows that pair up into a matrix.

Agent Skill

Create Package Skill gives a coding agent the workflow for building a new Colors Package Skill and a deployment that uses it — from requirements and credential boundaries through implementation, safe dry runs, and an authorized production deployment.

Installation
npx skills add getcolors/skills@create-package-skill
This is an Agent Skill, not a Package Skill. npx skills use gives it to your agent for the next request without installing it into a project.
Phase 1

Define

Agree on names, behavior, acceptance criteria, deployment target, credentials, cost, and authorization before touching files.

Phase 2

Scaffold safely

Create only non-secret desired state and credential placeholders, then stop for review. Secrets never enter chat or tracked files.

Phase 3

Build and deploy

Implement autonomously, test every layer, use real SHA pins, preserve safety guards, and deploy only within explicit authorization.

Agent Skill

Submit Package Skill gives a coding agent the workflow for validating an existing Colors Package Skill, adding its catalog recipe, and opening an authorized pull request for curated discovery on getcolors.ai.

Installation
npx skills add getcolors/skills@submit-package-skill
This is an Agent Skill, not a Package Skill. The Catalog adds discoverability only: GitHub remains the source, and npx skills remains the installer.
Phase 1

Validate

Inspect every SKILL.md and verify the Colors runtime, desired state, dry-run boundary, credential indirection, and lifecycle DAGs.

Phase 2

Add the recipe

Create one validated recipe for the product, grouping interchangeable runtime variants and infrastructure-oriented search keywords.

Phase 3

Open the PR

Run catalog validation and the site build, then create a branch, commit, push, fork, or pull request only with explicit authorization.

Agent Skill

Create Context Skill gives a coding agent the workflow for distilling a completed, verified build into a Context Skill conforming to the Context Skill Standard — symptom-first routing, provenance-labelled claims, pinned versions, a failure catalogue, and evals, with no copies of the companion package's files.

Installation
npx skills add getcolors/skills@create-context-skill
This is an Agent Skill, not a Package Skill. Its input is a completed build whose acceptance gates passed — without one, there is nothing to distill.
Phase 1

Harvest

Collect verbatim failures, review dispositions, deviations from documentation, and the exact pinned versions while the build's session still holds them.

Phase 2

Structure and route

Write the why into the body and the reference material into references, keep every claim provenance-labelled, and copy no file the companion package owns.

Phase 3

Prove and hand off

Write user-in-trouble evals, pass skills-ref validate, and stop: committing, pushing, and the catalog pull request each need explicit authorization.

Agent Skill

Submit Context Skill gives a coding agent the workflow for validating a Context Skill — knowledge distilled from a verified build — against the Context Skill Standard, adding its catalog recipe, and opening an authorized pull request for curated discovery on getcolors.ai.

Installation
npx skills add getcolors/skills@submit-context-skill
This is an Agent Skill, not a Package Skill. A Context Skill carries symptom-routed traps and acceptance doctrine; the Catalog adds discoverability only, and npx skills use remains how an agent loads it.
Phase 1

Validate

Read the skill and its references, run skills-ref validate, and verify symptom routing, provenance, pins, the failure catalogue, and evals.

Phase 2

Add the recipe

Create one type: context recipe naming the skill's repository, symptom-oriented search keywords, and the companion Package Skill it documents.

Phase 3

Open the PR

Run catalog validation and the site build, then create a branch, commit, push, fork, or pull request only with explicit authorization.

Browse the PR-curated Skills Catalog by platform, provider, or runtime.

View the Catalog