Project Boilerplate

The app template is a ready-to-run VSKI project: a declarative deployment, a demo plugin, a docker-compose stack and an e2e test suite, wired together with a Makefile. vski init bootstraps a new project from it in one command.

Bootstrap

vski init my-app          # clones the template (main) and strips its .git
cd my-app
make venv                 # .venv with vski-sdk[cli] + test tooling

export VSKI_URL=http://127.0.0.1:3000
export VSKI_API_KEY=vski_...      # mint with `vski keys create`

make iac-plan            # preview the deployment
make iac-apply           # apply it

Variants:

vski init my-app --ref v0.10.0        # a specific template tag
vski init my-app --from ../template   # a local checkout or fork URL

Prefer starting from an empty sheet? vski setup writes just the starter vski/ YAML (see Command Line).

What's inside

Path	What it is
vski/	The declarative deployment: databases, collections, plugins, pipelines, cron, secrets YAML
src/hello/	A demo plugin (echo functions) referenced by the pipeline
Makefile	venv, IaC (iac-plan / iac-apply / iac-pull), stack control, tests
docker-compose.yml (+ .dev, .e2e)	Server stack; overlays add the plugin-enabled dev build and an isolated e2e project
test/e2e/	Pytest suite: stack up, apply the YAML, run the pipeline, assert the output
.env.example	VSKI_URL / VSKI_API_KEY and friends

The demo deployment (all in vski/):

• a notes collection (title/body fields, a created index, read rules open to authenticated clients, writes admin-only)
• a hello plugin instance (config-only: the plugin code lives in src/hello, mounted into the dev stack)
• a note-intake pipeline with a collection trigger and a plugin step that echoes {{trigger.record.title}}
• a nightly cron kick (pipeline://note-intake) and a secrets entry wired with fromEnv (values never in YAML)

Day-to-day targets

make up          # start the stack (server + plugin-enabled build)
make dev         # stack + hot-reloading plugin source
make logs        # follow stack logs
make test        # unit + e2e suites (e2e spins its own isolated stack)
make iac-pull    # export live state back to YAML
make down        # stop everything

Why start from the template

• Everything reviewed in one place: schema, rules, pipelines and plugin instances are YAML in git from day one (see Infrastructure as Code)
• The loop is pre-wired: make iac-plan doubles as a CI gate (exit code 2 on drift), and the e2e suite exercises the whole stack including the plugin
• The plugin story is real: the dev overlay mounts src/ into the server container so plugin code changes restart exactly one process

Strip what you don't need: the notes/hello/note-intake trio is a walking skeleton, delete the YAML entries and src/hello when you outgrow them.