Skip to content

GoCodeAlone/workflow-registry

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

145 Commits
.github/workflows
.github/workflows
 
 
docs/plans
docs/plans
 
 
plugins
plugins
 
 
schema
schema
 
 
scripts
scripts
 
 
templates
templates
 
 
tests
tests
 
 
.gitignore
.gitignore
 
 
LICENSE
LICENSE
 
 
README.md
README.md
 
 

Repository files navigation

workflow-registry

Validate Registry Build & Deploy

The official plugin and template registry for the GoCodeAlone/workflow engine.

Registry API: https://gocodealone.github.io/workflow-registry/v1/

This registry catalogs built-in plugins, first-party external plugins, community extensions, and reusable templates that can be used with the workflow engine. It serves as the source of truth for the wfctl CLI's marketplace and wfctl publish command.

Table of Contents

What is this?

The workflow engine is built around a plugin system. Every capability — HTTP servers, messaging brokers, state machines, AI steps, CI/CD pipelines — is provided by a plugin. This registry tracks:

  • Plugins: Packages that extend the engine with new module types, pipeline steps, triggers, and workflow handlers
  • Templates: Starter configurations for common workflow patterns

The registry is consumed by:

  • wfctl marketplace — browse and search available plugins
  • wfctl publish — submit your plugin to the registry
  • The workflow UI Marketplace page
  • The static JSON API at https://gocodealone.github.io/workflow-registry/v1/

Usage via wfctl

# Search for plugins by keyword
wfctl marketplace search http

# Get details for a specific plugin
wfctl marketplace info payments

# Install a plugin into your project
wfctl install payments

# List all installed plugins
wfctl plugin list

# Update all plugins to latest versions
wfctl plugin update

Plugin Tiers

Tier Description
core Maintained by GoCodeAlone as a first-party capability with guaranteed compatibility
community Third-party plugins submitted via PR, reviewed by maintainers
premium Commercial plugins with additional licensing requirements

Manifest type describes distribution (builtin, external, or ui); tier describes ownership and support level.

All plugins in this registry must pass manifest schema validation before merging.

Built-in Plugins

These plugins ship in the GoCodeAlone/workflow engine and are available without installing a separate plugin repository.

Plugin Description
actors Actor model support with goakt v4
admincore Core admin-console UI navigation pages, provided as a built-in native plugin
agent AI agent primitives for workflow apps — provider abstraction, execution loop, tool registry, memory, loop detection, orchestration (SSE hub, scheduler, MCP client/server, approvals, sub-agents, webhooks, security auditing, JWT, bcrypt, OAuth)
ai AI pipeline steps (complete, classify, extract), dynamic components, and sub-workflow orchestration
api REST API handlers, CQRS query/command, API gateway, and data transformation
auth JWT authentication, OAuth2, user store, and auth middleware wiring
cicd CI/CD pipeline step types (shell exec, Docker, artifact management, security scanning, deploy, gate, build from config, git operations, AWS CodeBuild)
cloud Cloud provider credentials and validation. Foundation for IaC modules.
configprovider Application configuration registry with schema validation, defaults, and source layering
datastores NoSQL data store modules and pipeline steps
dlq Dead letter queue service module for failed message management
docmanager Markdown documentation management HTTP API (documents and categories), provided as a built-in native plugin
eventstore Event store service module for execution event persistence
featureflags Feature flag service module and pipeline steps (feature_flag, ff_gate)
gitlab GitLab CI integration: webhook receiver (gitlab.webhook), API client (gitlab.client), pipeline trigger/status steps, and MR management steps.
http HTTP server, router, handlers, middleware, proxy, and static file serving
infra Abstract infra.* module types with IaCProvider delegation
integration Integration workflow handler for connector-based multi-system workflows
k8s Native Kubernetes deployment support using client-go. Provides generate, apply, destroy, status, diff, and logs operations without requiring kubectl or Helm.
license License validation with remote server, local cache, and grace period
marketplace Plugin marketplace steps for searching, installing, and managing workflow plugins
mcp MCP tool triggers, workflow handlers, and server registry
messaging Messaging subsystem: brokers, handlers, triggers, and workflows
modularcompat GoCodeAlone/modular framework compatibility modules (scheduler, cache, jsonschema)
observability Metrics, health checks, log collection, OpenTelemetry tracing, and OpenAPI spec generation/consumption
openapi OpenAPI v3 spec-driven HTTP route generation with request validation and Swagger UI
pipelinesteps Generic pipeline step types, pre-processing validators, and pipeline workflow handler (including base64_decode)
platform Platform infrastructure modules, workflow handler, reconciliation trigger, and template step
policy Policy engine plugin with mock backend for testing and development
scanner Security scanner provider with pluggable backends
scheduler Scheduler workflow handler and schedule trigger for cron-based job execution
secrets Secrets management modules (Vault, AWS Secrets Manager, OS Keychain)
statemachine State machine engine, tracker, connector modules and workflow handler
storage Storage, database, persistence, and cache modules with DB pipeline steps
storebrowser Read-only browser for engine stores (tables, events, dead-letter queue) with a parameterized SQL query endpoint, provided as a built-in native plugin
timeline Timeline and replay service module for execution visualization

First-party External Plugins

These plugins are maintained by GoCodeAlone as core platform capabilities, but are distributed outside the engine repository.

Plugin Description
admin Admin dashboard UI and config-driven admin routes with embedded React UI. Provides user management, workflow management, settings, and real-time monitoring.
approval Human-in-the-loop approval workflows with state machine
audit Compliance audit logging with EventBus collection and S3/database sinks
authz RBAC authorization plugin using Casbin
bento Stream processing via Bento — 100+ connectors, Bloblang transforms, at-least-once delivery
ci-generator CI/CD config generator for GitHub Actions, GitLab CI, Jenkins, and CircleCI
crm Vendor-neutral CRM integration with Salesforce adapter
data-engineering Data engineering: CDC, lakehouse (Iceberg), time-series (InfluxDB/TimescaleDB/ClickHouse/QuestDB/Druid), graph (Neo4j), data quality, migrations, catalog (DataHub/OpenMetadata)
erp Enterprise ERP integration via OData v4 with SAP adapter
github GitHub integration plugin: webhook handling, GitHub Actions, PRs, issues, releases, and deployments
payments Multi-provider payment processing plugin (Stripe, PayPal)
sso Enterprise SSO via OpenID Connect with multi-provider support
tofu OpenTofu/Terraform adapter: HCL generation from abstract infra specs, plan/apply execution, and state import/export
vectorstore Vector database integration for RAG pipelines with Pinecone support
websocket General-purpose WebSocket support — rooms, broadcast, send, close
workflow-plugin-auth Passwordless authentication plugin: WebAuthn/passkeys, TOTP, email magic links
workflow-plugin-supply-chain Supply chain security: SBOM generation, keyless signing, SLSA provenance, vulnerability scanning, and wfctl CLI extensions

Community and Premium External Plugins

These plugins are distributed outside the engine repository and are maintained as community or commercial extensions.

Plugin Description Tier
analytics Analytics and tag-manager injection for rendered HTML assets community
audit-chain Tamper-evident hash-chained audit logging with periodic Merkle root anchoring (OpenTimestamps/Bitcoin, git, Sigstore) community
auth0 Auth0 identity and access management provider plugin community
authz-ui Casbin authorization policy management UI (React SPA) premium
aws AWS provider plugin for workflow IaC — manages ECS, EKS, RDS, ElastiCache, VPC, ALB, Route53, ECR, API Gateway, Security Groups, IAM, S3, and ACM resources community
azure Microsoft Azure infrastructure provider: ACI, AKS, SQL, Redis, VNet, LB, DNS, ACR, APIM, NSG, MSI, Blob Storage, App Service Certificates community
broker External plugin for the workflow engine. community
cloud-ui Cloud management UI plugin (React SPA) premium
cloudflare Cloudflare DNS provider for workflow IaC (infra.dns) community
cms Multi-tenant CMS engine — TenantResolver + static-wins routing + WYSIWYG page authoring (TipTap default). Foundation of gocodealone-multisite. community
datadog Datadog monitoring and observability — metrics, events, monitors, dashboards, logs, synthetics, SLOs, incidents, and more community
digitalocean DigitalOcean IaC provider: App Platform, DOKS, databases, Redis cache, load balancers, VPC, firewall, DNS, Spaces, DOCR, certificates, Droplets, Block Storage Volumes, IAM, and API gateway community
discord Discord messaging, bot automation, and voice channel support. Provides a provider module, pipeline steps for sending/editing/deleting messages and managing voice, and a WebSocket Gateway event trigger. community
edge-compute Edge WASM provider contracts for workflow-compute community
entra Microsoft Entra ID management provider plugin community
eventbus Provisions durable event-bus clusters (NATS / Kafka / Kinesis) as IaC and exposes typed pipeline steps for publish / consume operations. community
gcp GCP infrastructure provider plugin for workflow — manages Cloud Run, GKE, Cloud SQL, Memorystore, VPC, Load Balancer, Cloud DNS, Artifact Registry, API Gateway, Firewall, IAM, GCS, and Certificate Manager community
hover Hover DNS provider for workflow IaC (infra.dns). No official API; mimics the browser-side username+password+TOTP login flow used by pjslauta/hover-dyn-dns. community
launchdarkly LaunchDarkly feature management — flags, segments, environments, projects, metrics, experiments, approvals, audit log, and more community
messaging-core Shared messaging interfaces for workflow platform plugins community
monday Comprehensive monday.com integration — boards, items, columns, groups, workspaces, and all resources via GraphQL community
namecheap Namecheap DNS provider for workflow IaC (infra.dns) backed by the official go-namecheap-sdk. community
okta Okta identity and access management — users, groups, applications, authorization servers, MFA, policies, and more community
openlms OpenLMS learning management — courses, enrollments, grades, assignments, quizzes, users, competencies, calendars, forums, and more community
ratchet Autonomous AI agent orchestration platform — custom EnginePlugin for building AI-powered workflow applications with agent coordination, task management, and intelligent pipeline execution community
rooms Room management plugin for workflow engine — join, leave, broadcast, members community
salesforce Salesforce CRM — records, SOQL queries, bulk operations, approvals, flows, reports, dashboards, metadata, and more community
scalekit Scalekit enterprise SSO and Directory Sync provider plugin community
security-scanner Security scanner plugin for workflow engine — vulnerability scanning, secret detection, and compliance checks community
security Unified security plugin: WAF (Coraza/AWS/GCloud/Cloudflare), MFA/encryption (TOTP, AES-256-GCM, AWS KMS, GCP KMS, Vault Transit), authorization (Casbin RBAC, Permit.io), data protection (PII detection/masking), sandbox (WASM/wazero, Docker), and supply-chain security (signatures, vuln scanning, SBOM) premium
slack Slack messaging and workspace automation. Provides a provider module backed by the Slack Web API and Socket Mode, pipeline steps for messages/blocks/reactions/files, and a Socket Mode event trigger. community
steam External plugin for the workflow engine. community
teams Microsoft Teams messaging and channel management via the Microsoft Graph API. Provides a provider module with Azure AD client credentials auth, pipeline steps for messages/cards/channels/members, and an HTTP webhook trigger for Graph change notifications. community
template Template repository for creating workflow engine external plugins community
turnio turn.io WhatsApp API integration — messaging, contacts, templates, flows, and journeys community
twilio Comprehensive Twilio integration — SMS, Voice, Verify, Video, Conversations, TaskRouter, and 40+ products community
workflow-plugin-atlas-migrate Atlas migration driver plugin for the workflow engine: ariga.io/atlas v1 backed Up/Down/Status/Goto with SQL-backed revision tracking and auto-generated atlas.sum community
workflow-plugin-compute Workflow adapter for workflow-compute dispatch, wait, map, provider, pool, catalog, and product-capture workloads community
workflow-plugin-infra Abstract infra.* module types with IaCProvider delegation + dynamic plan/apply SPA, exec-env, and reconcile (plugs into workflow-plugin-admin) community
workflow-plugin-migrations Database migration plugin for the workflow engine: golang-migrate + goose drivers, pre-deploy runner, wfctl migrate CLI, static lint tool, and tenant-ensure schema setup community
workflow-plugin-product-capture Product URL capture provider for workflow-compute community
ws-auth WebSocket HMAC authentication plugin for workflow engine community

Templates

Starter configurations for common workflow patterns:

Template Description
api-service HTTP API with JWT auth, SQLite storage, and composable pipelines
event-processor Event-driven processor using EventBus, pipelines, and optional Kafka/NATS integration
full-stack Full-stack application with HTTP server, auth, state machine, storage, messaging, scheduling, and observability
plugin Scaffold for a new external workflow engine plugin with module factory, step factory, and wiring hooks
stream-processor Stream processing pipeline using the Bento plugin with input ingestion, Bloblang transformation, and output archival
ui-plugin Scaffold for a React-based UI plugin that extends the workflow builder with custom node types or pages

Initialize a project from a template:

wfctl init my-project --template api-service

Schema

All plugin manifests must conform to the registry schema. The schema is a JSON Schema (draft 2020-12) defining required fields, enums for type, tier, and status, and the structure of capabilities.

The optional status field tracks active-usage verification: "verified" means the plugin is pinned in a merged main-branch wfctl.yaml of an active GoCodeAlone project (production miles); "experimental" means it compiles and unit-tests pass but has no validated production deployment; "deprecated" means it is scheduled for removal. Manifests without status continue to validate — the field is optional and additive.

Validate a manifest locally:

# Validate a single manifest
npx ajv-cli validate --spec=draft2020 -s schema/registry-schema.json -d plugins/my-plugin/manifest.json

# Validate all manifests at once
bash scripts/validate-manifests.sh

# Validate built-in core manifests against workflow plugin declarations
wfctl plugin registry-sync core --workflow-repo /path/to/workflow --registry-dir .

# Validate template plugin references
bash scripts/validate-templates.sh

# Validate the README plugin/template index is current
wfctl plugin registry-sync readme --check --registry-dir .

Local Pre-commit Hook

Install the provided pre-commit hook to catch validation errors before they reach CI:

cp scripts/pre-commit .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

The hook runs scripts/validate-manifests.sh when plugins/*/manifest.json or schema/registry-schema.json are staged, and scripts/validate-templates.sh when templates/*.yaml files are staged.

CI/CD

Every pull request and push to main triggers the Validate Registry workflow, which:

  1. Validates all plugins/*/manifest.json files against schema/registry-schema.json (JSON Schema draft 2020-12 via ajv-cli)
  2. Checks built-in core plugin manifests against the current GoCodeAlone/workflow plugin declarations
  3. Checks that README.md matches the generated registry index
  4. Checks that every plugin referenced in templates/*.yaml has a corresponding manifest

The Sync Registry Manifests workflow runs daily, manually, and on plugin-release or workflow-release dispatch events. It uses wfctl plugin registry-sync to update release metadata, sync built-in core manifests from GoCodeAlone/workflow, regenerate this README, and open a PR when tracked registry files change. The old scripts/sync-versions.sh, scripts/sync-core-manifests.sh, and scripts/generate-readme.sh entrypoints are compatibility wrappers around the same wfctl commands.

The Build & Deploy workflow runs on every push to main, on a daily schedule, and whenever a plugin sends a plugin-release dispatch event. It:

  1. Generates v1/index.json from all manifests
  2. Queries GitHub Releases for each plugin to build v1/plugins/<name>/versions.json
  3. Deploys the v1/ directory to GitHub Pages

PRs that fail validation cannot be merged.

Submitting a Plugin

Step-by-step PR Process

  1. Fork this repository
  2. Create a directory under plugins/<your-plugin-name>/
  3. Add a manifest.json that conforms to the registry schema
  4. Validate your manifest locally: 
    bash scripts/validate-manifests.sh
  5. Open a PR with a description of your plugin, what it provides, and a link to the source repository

Manifest Requirements

  • name, version, author, description, type, tier, license are required
  • type must be "external" for community plugins (only GoCodeAlone sets "builtin")
  • tier must be "community" for third-party submissions
  • repository should point to the public GitHub repository where the plugin lives
  • capabilities.moduleTypes, stepTypes, triggerTypes, workflowHandlers must accurately reflect what the plugin registers
  • private: true must be set for plugins that are not publicly installable
  • status is optional; if set, must be one of "verified", "experimental", or "deprecated" (see Schema section)

Review Process

PRs are reviewed by maintainers for:

  • Schema validity
  • Accurate capability declarations
  • Source repo accessibility
  • License compatibility

Automatic Version Tracking

When you publish a new release of your plugin, you can automatically trigger a registry rebuild so that v1/plugins/<name>/versions.json and v1/plugins/<name>/latest.json are updated within minutes.

See templates/notify-registry.yml for the reusable workflow snippet to add to your plugin's release workflow.

Setup:

  1. Create a GitHub PAT with repo scope for GoCodeAlone/workflow-registry
  2. Add it as a secret named REGISTRY_PAT in your plugin repo
  3. Copy the notify-registry job from the template into your .github/workflows/release.yml

The registry rebuilds daily at 06:00 UTC as a fallback even without dispatch events.

Registry Structure

workflow-registry/
├── plugins/                    # Source of truth — one directory per plugin
│   └── <name>/
│       └── manifest.json       # Plugin metadata and capabilities
├── templates/                  # Reusable workflow config templates
│   ├── notify-registry.yml     # Action snippet for plugin release notifications
│   └── *.yaml                  # Workflow starter templates
├── schema/
│   └── registry-schema.json    # JSON Schema for manifest validation
├── scripts/
│   ├── build-index.sh          # Generates v1/index.json
│   ├── build-versions.sh       # Queries GitHub Releases → v1/plugins/*/versions.json
│   ├── validate-manifests.sh   # CI manifest validation
│   └── validate-templates.sh   # CI template validation
├── .github/workflows/
│   ├── validate.yml            # PR validation gate
│   └── build-pages.yml         # Build and deploy static registry to GitHub Pages
└── v1/                         # Generated — served via GitHub Pages (not committed)
    ├── index.json              # Array of all plugin summaries, sorted by name
    └── plugins/
        └── <name>/
            ├── manifest.json   # Copy of source manifest
            ├── versions.json   # Release history from GitHub
            └── latest.json     # Latest release entry only

Static API Endpoints

Endpoint Description
GET /v1/index.json All plugin summaries (name, description, version, capabilities, ...)
GET /v1/plugins/<name>/manifest.json Full manifest for a specific plugin
GET /v1/plugins/<name>/versions.json All release versions with download URLs
GET /v1/plugins/<name>/latest.json Latest release version only

Plugin Authoring Guide

See the Plugin Manifest Format section below and the registry schema for a complete reference on building, testing, and publishing a workflow engine plugin.

Plugin Manifest Format

{
  "name": "my-plugin",
  "version": "1.0.0",
  "author": "your-github-username",
  "description": "What this plugin provides",
  "source": "github.com/yourorg/my-plugin",
  "path": ".",
  "type": "external",
  "tier": "community",
  "license": "MIT",
  "minEngineVersion": "0.1.0",
  "repository": "https://github.com/yourorg/my-plugin",
  "keywords": ["tag1", "tag2"],
  "capabilities": {
    "moduleTypes": ["mymodule.type"],
    "stepTypes": ["step.my_step"],
    "triggerTypes": [],
    "workflowHandlers": []
  }
}

Full schema documentation: schema/registry-schema.json

License

MIT — see LICENSE

About

Plugin and template registry for the GoCodeAlone/workflow engine

Resources

Readme

License

MIT license
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages