casen connector

casen connector has two independent jobs: browse the bundled connector templates — Camunda 8’s 133 out-of-the-box ones plus the few BPMN Kit maintains (search/show — used by the AI generation pipeline to wire a plan step to a real service), and generate brand-new connector element templates from OpenAPI 3.x/Swagger 2.x specs (generate/catalog — for APIs Camunda doesn’t ship a template for).

Commands

casen connector
├── search      — find a bundled OOTB connector template by name/keyword
├── show        — show a bundled template's required/optional inputs
├── cards       — one card per operation: only the inputs it needs, for a request
├── api         — real endpoints of an HTTP API, from the offline API index, for the REST connector
├── generate    — generate new templates from an OpenAPI spec file or catalog entry
└── catalog     — list all built-in OpenAPI-catalog entries (for `generate`)

Browse the bundled OOTB catalog

casen connector search slack
casen connector show io.camunda.connectors.Slack.v1

search scores the bundled templates by keyword match and prints a table (template id, direction, task type, description). show prints a template’s task type, direction, and its required/optional input keys — these are the keys a ProcessPlan connector step’s values object uses (see Building Processes with AI):

$ casen connector show io.camunda.connectors.Slack.v1
Slack connector  (io.camunda.connectors.Slack.v1)
Task type: io.camunda:slack:1
Direction: outbound
Create a channel or send a message to a channel or user

Required inputs:
  token (secret) — OAuth token
  data.channel — Channel/user name/email
  data.text — Message
  ...

A field marked (secret) should be supplied as a {{secrets.NAME}} placeholder, never a literal credential. This is the same catalog @bpmnkit/connectors’ listConnectors()/searchConnectors() expose programmatically.

show lists every input of a template, whichever operation it belongs to: GitHub’s lists owner for each of its operations. cards answers a request with one card per operation instead, each with only the inputs that operation uses, and the values that select it:

$ casen connector cards "create a github issue" --limit 1
github createIssue — GitHub Outbound Connector: Issues / Create an issue | owner* repo* issueTitle* | optional: authentication.pat(secret) githubBody issueAssignees(=FEEL) issueLabels(=FEEL) issueMilestone resultVariable resultExpressionCreateIssue(=FEEL) | authentication.authType=pat: pat | github_app
  values: {"operationGroup":"issues","issueOperationType":"createIssue"}

* marks a required input. A mode=default: a | b(…) part is a choice inside the operation, such as an authentication type, with the required inputs each choice adds. Retries, timeouts, TLS and other plumbing are left out unless you pass --advanced; -o json prints the cards as data.

Endpoints of an HTTP API

Most systems have no dedicated connector, so the REST connector calls them. api prints the real base URL, authentication and endpoints from the offline API index. It searches the service the request names, or the one --service gives:

$ casen connector api "refund a stripe payment" --limit 1
api stripe — Stripe API https://api.stripe.com auth=bearer secret=STRIPE_TOKEN
POST /v1/refunds — Create a refund | form body: amount currency charge customer expand instructions_email

Write the call as with <id>: http POST /v1/refunds | api=stripe. Applying the line adds the base URL, the authentication with a secret placeholder, and the headers the endpoint needs. -o json prints the endpoints as data.

Generate from the OpenAPI catalog

The fastest way to get started. The catalog contains 30 popular APIs with pre-configured spec URLs and auth defaults:

# List all available catalog entries
casen connector catalog

# Generate templates for the Stripe API
casen connector generate --api stripe --output ./templates/

# Generate templates for GitHub with a custom ID prefix
casen connector generate --api github --id-prefix com.myorg --output ./templates/

Generate from a local file

Pass any local OpenAPI 3.x or Swagger 2.x file in YAML or JSON format:

casen connector generate --swagger ./openapi.yaml --output ./templates/

# JSON format works too
casen connector generate --swagger ./api-spec.json --output ./templates/

All flags

Auth types

Auth is auto-detected from components.securitySchemes in the spec. Use --auth to override.

Common workflows

Preview before writing

Use --dry-run to inspect the generated JSON before committing to files:

casen connector generate --api resend --dry-run

Filter to a subset of operations

Large APIs (GitHub, Stripe) produce hundreds of templates. Use --filter to narrow it down:

# Only generate templates for issue-related operations
casen connector generate --api github --filter "issues" --output ./templates/

# Only POST and PUT operations (filter on summary/operationId)
casen connector generate --api stripe --filter "create|update" --output ./templates/

Expand request body fields

By default the request body is a single FEEL Text field. Use --expand-body to decompose top-level properties into individual typed input fields — useful for simple, well-documented APIs:

casen connector generate --api resend --expand-body --output ./templates/

All templates in one file

casen connector generate --api slack --format array --output ./templates/
# Writes: ./templates/slack.json  (array of all templates)

Override the base URL

Useful when targeting a self-hosted or staging instance:

casen connector generate --swagger ./openapi.yaml \
  --base-url https://staging-api.mycompany.com \
  --output ./templates/

What gets generated

Each operation in the spec becomes one Camunda element template JSON file. The template pre-configures a bpmn:ServiceTask with job type io.camunda:http-json:1 and wires up:

• Method and URL — hidden fixed fields; path parameters become FEEL expressions (e.g. ="https://api.example.com/users/"+userId)
• Path parameters — individual String input fields
• Query parameters — mapped to a FEEL context object
• Headers — mapped to a FEEL context object
• Request body — single FEEL Text field, or individual typed fields with --expand-body
• Authentication — full 5-type auth block with visibility conditions; pre-selected to the detected or specified auth type
• Output mapping, error expression, retries, and timeout — standard connector fields

Import the generated .json files into Camunda Modeler via File → Import Element Templates or by placing them in your .camunda/element-templates/ directory.

Built-in catalog

casen connector catalog

Programmatic usage

The underlying generator is available as a standalone package for use in Node.js scripts and build pipelines. See @bpmnkit/connector-gen.