CI/CD Pipeline Configuration for usekaneo/kaneo: Full GitHub Actions Breakdown

The usekaneo/kaneo repository uses GitHub Actions to implement a comprehensive CI/CD pipeline that covers linting, unit testing, building, integration testing, and Docker image validation through five coordinated jobs defined in .github/workflows/ci.yml.

The Kaneo project, a Kubernetes-native workflow orchestration tool, relies entirely on GitHub Actions for its software delivery lifecycle. Understanding the CI/CD pipeline configuration for usekaneo/kaneo reveals how a modern TypeScript monorepo achieves reliable, reproducible deployments from code commit to production container.

Core CI Pipeline: The Main Workflow

The heart of Kaneo's automation lives in .github/workflows/ci.yml. This workflow triggers on every push and pull request to the repository, executing five sequential verification jobs on ubuntu-24.04 runners.

1. Lint Job: Code Quality Enforcement

The lint job ensures code consistency using Biome, a fast Rust-based toolchain. As implemented in usekaneo/kaneo, this job runs:

pnpm exec biome ci .

The job definition spans lines 11-33 of the workflow file and follows a standardized setup pattern: checkout, pnpm v10.32.1 installation, Node.js 20.20.2 setup with caching, frozen lockfile dependency installation, then the lint command itself.

2. Unit Job: Fast Feedback on Logic

The unit job (lines 34-55) reuses the identical environment preparation, then executes:

pnpm test

This runs the monorepo's unit test suite across all packages without external dependencies.

3. Build Job: Compilation Verification

The build job (lines 57-78) confirms the entire TypeScript monorepo compiles cleanly:

pnpm build

This catches type errors and build-time failures that unit tests might miss.

4. Integration Job: Database-Backed Testing

The integration job (lines 80-123) represents the most complex verification stage. It spins up a real PostgreSQL 16 service container with health checks, injects test environment variables including a test-only AUTH_SECRET, then runs:

pnpm test:integration

This validates API behavior against an actual database rather than mocks, catching migration issues and query regressions.

5. Docker-Build Job: Image Smoke Test

The final CI job (lines 124-141) validates the containerization layer without publishing:

docker buildx build -f Dockerfile.kaneo --cache-from type=gha --cache-to type=gha

This uses Docker Buildx with GitHub Actions cache mounts to speed up subsequent runs.

CD Workflows: Release and Deployment Automation

Beyond continuous integration, the CI/CD pipeline configuration for usekaneo/kaneo includes five dedicated deployment workflows triggered by releases:

release.yml: Version and Artifact Publishing

The release.yml workflow orchestrates semantic versioning. It publishes new npm package versions to the registry, creates annotated GitHub releases with changelogs, and attaches built artifacts for distribution.

publish-mcp.yml: Multi-Container Image Build

The publish-mcp.yml workflow specifically handles the MCP (multi-container package) Docker image. This triggers after a successful release, building optimized production images and pushing to the configured container registry.

docker.yml: Tagged Release Images

The docker.yml workflow provides an additional Docker build path specifically for git tags, ensuring every versioned release has a corresponding immutable container image.

helm-chart.yml: Kubernetes Packaging

For operators deploying to Kubernetes, helm-chart.yml lints the Helm chart definition, packages it, and publishes to the chart repository. This enables helm install kaneo workflows for end users.

deploy-site.yml: Documentation Automation

The deploy-site.yml workflow completes the CD picture by building and deploying the static documentation site to GitHub Pages on each release, ensuring docs stay synchronized with code.

Local CI Simulation

Developers can reproduce the entire CI pipeline locally using the exact tool versions locked in the workflow:

# Match CI's pnpm version exactly

npm i -g pnpm@10.32.1

# Reproduce the frozen installation

pnpm install --frozen-lockfile

# Execute each CI stage locally

pnpm exec biome ci .          # lint

pnpm test                     # unit

pnpm build                    # build check

pnpm test:integration         # requires local Postgres

docker build -f Dockerfile.kaneo -t kaneo:local .

Triggering a Full Release

To initiate the CD pipeline:

npm version patch -m "Release %s"
git push origin main --tags

This tag push triggers release.yml, which then chains into publish-mcp.yml, helm-chart.yml, and deploy-site.yml through workflow dependencies or repository dispatch events.

Key Configuration Files

File	Purpose
.github/workflows/ci.yml	Five-job CI pipeline with lint, unit, build, integration, and Docker validation
.github/workflows/release.yml	Version bumping, npm publishing, and GitHub release creation
.github/workflows/publish-mcp.yml	Production Docker image build and registry push
.github/workflows/docker.yml	Tag-triggered Docker image builds
.github/workflows/helm-chart.yml	Kubernetes Helm chart linting and packaging
.github/workflows/deploy-site.yml	Documentation site deployment to GitHub Pages
Dockerfile.kaneo	Multi-stage container definition for the Kaneo application
package.json	Monorepo script definitions (test, build, test:integration)

Summary

• The CI/CD pipeline configuration for usekaneo/kaneo centers on .github/workflows/ci.yml with five verification jobs running on ubuntu-24.04
• Every job uses pnpm v10.32.1 and Node.js 20.20.2 with frozen lockfiles for reproducible builds
• Integration testing requires a real PostgreSQL 16 service with health-checked startup
• Docker smoke tests use Buildx with GitHub Actions cache without pushing images
• Five separate CD workflows handle releases, container publishing, Helm packaging, and documentation deployment
• The entire pipeline can be simulated locally using the exact tool versions specified in the workflow files

Frequently Asked Questions

Where is the main CI workflow defined in usekaneo/kaneo?

The primary CI workflow lives in .github/workflows/ci.yml. It contains five jobs—lint, unit, build, integration, and docker-build—that execute on every push and pull request.

What database does Kaneo use for integration testing?

The integration job spins up a PostgreSQL 16 service container with health checks. Tests run via pnpm test:integration against this real database instance rather than mocks or SQLite.

How can I run the CI checks locally before pushing?

Install pnpm@10.32.1, run pnpm install --frozen-lockfile, then execute the same commands as CI: pnpm exec biome ci ., pnpm test, pnpm build, and pnpm test:integration (requires local Postgres).

What triggers the release and deployment workflows?

Pushing a git tag triggers release.yml, which publishes npm packages and creates GitHub releases. This cascades into publish-mcp.yml (Docker images), helm-chart.yml (Kubernetes charts), and deploy-site.yml (documentation).

Does Kaneo use Docker Hub for container images?

Yes. The docker.yml and publish-mcp.yml workflows build and push images to Docker Hub or the configured registry when tags are created or releases are published.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}