Install cronstable using Winget - wingetCollections

"Crontab" is in YAML format; classic crontab files are accepted as-is too (see Classic crontab files)
Business-day schedules: LW (the month's last weekday), L-3 (three days before month-end), 15W (the weekday nearest the 15th), and 5#3 (the third Friday) express payroll/billing-style cadences directly, and Quartz day expressions largely paste straight in (see the Business-Day Schedules wiki page)
Built-in schedule linting: dead schedules that can never fire again are called out loudly (never silently dropped), and common footguns (AND day semantics, uneven */n steps, day-31-in-April, schedules that DST skips or repeats) are flagged at config load, in the dashboards, and over the API (see Schedule introspection)
Builtin sending of Sentry, Mail, and webhook (Slack-compatible) notifications when cron jobs fail
End-to-end encrypted push notifications: a dedicated reporter seals each alert to a paired device's own key (libsodium sealed box), so the relay that forwards it to the platform push service never sees job names, hostnames, or log lines; pairing is a dashboard QR scan or one API call, and an opt-in Bonjour/mDNS advert lets a companion app find the daemon on the LAN (see Push notifications and the Push Notifications and LAN Discovery wiki pages)
Flexible configuration: you decide how to determine if a cron job fails or not
Designed for running in Docker, Kubernetes, or 12 factor environments:
- Runs in the foreground
- Logs everything to stdout/stderr
- Production-ready for locked-down corporate container platforms: runs as a non-root user, under a restricted seccomp profile, with a read-only root filesystem, an fsGroup-mounted config, and all Linux capabilities dropped, so no writable paths or elevated privileges are required (see Production container deployment)
Option to automatically retry failing cron jobs, with exponential backoff
Per-job SLA monitoring: an sla: block declares thresholds for the runs that did not happen: too long without a success, a due slot that never started, a run exceeding its runtime bound. A breach fires a dedicated onLate reporting hook once (mail, Sentry, shell, webhook), gauges and counters land in the metrics, and the dashboards badge the job OVERDUE (see Late-run detection and the Late-Run Detection wiki page)
Runtime pause/resume: pause any job's scheduled fires for a bounded window (an hour by default, thirty days at most) over the API, the dashboards, or MCP, without touching the config. Skipped slots are recorded visibly, pending retries defer, catch-up owes nothing for the window, and with a state: store the pause survives restarts and is honored by every node (see the Pausing Jobs wiki page)
Opt-in durable state: point a single state: config block at a local directory (or an Amazon S3 Files / EFS mount to share it fleet-wide) and jobs gain durability across restarts: missed-run catch-up after downtime and retries that survive a daemon restart. The same store is handed to the jobs themselves over a loopback endpoint, so a job command can reach for durable key/value, an ETL cursor/watermark, a fleet-wide mutex or semaphore, idempotency keys, a shared artifact store and run-scoped secrets with cronstable state|cursor|lock|artifact|idempotent|secret (see the Durable State wiki page); without it, cronstable stays stateless as before
Opt-in orchestration DAGs: a dags: block turns the scheduler into a small, durable workflow engine: tasks with dependsOn edges, cross-task data hand-off (XCom), dynamic fan-out/mapping, sensors, human approval gates, whole-DAG backfill, and crash-resume of a partial graph, all on the same state store and coordinated across a fleet under a single lease so a task never double-launches (see the Orchestration and DAGs wiki page)
Optional HTTP REST API, to fetch status, start jobs, cancel running jobs, and read per-job run history on demand
Native TLS on the listeners: web.listen accepts https:// addresses served from a web.tls block, mixed freely with plaintext and unix-socket entries on one runner, and an optional clientCa makes the listener require a client certificate signed by your own CA (mutual TLS), so it authenticates its callers rather than merely encrypting them. A web certificate replaced in place is picked up without a daemon restart. The job-facing state API gains the same block as state.jobApi.tls, and cronstable tui / cronstable mcp gain --cacert, --client-cert, --client-key and --insecure (see Serving the API over TLS and the Listener TLS wiki page)
iCal calendar export: subscribe any calendar app to GET /calendar.ics (or one job's /jobs/{name}/calendar.ics) and the fleet's upcoming fires, enumerated by the scheduler's own engine, land on the on-call engineer's calendar; the dashboard draws the same data as a seven-day week calendar (see the Calendar Export wiki page)
Optional MCP server for AI agents. An agent can observe cronstable, author and debug schedules with the daemon's own engine (validate/explain an expression, explain field by field why a job did not run at a timestamp), and control it when you opt in. It is read-only by default and exposes tools, resources, and triage prompts covering jobs, DAGs, the cluster/fleet, metrics, and durable state. It is served at POST /mcp on the web listeners and through a cronstable mcp stdio bridge, and is hand-rolled in pure Python with no new dependencies
Native Prometheus metrics at /metrics (plus per-job statsd push metrics), covering run outcomes, durations, retries, schedules, and cluster health (see Metrics)
Opt-in per-job resource monitoring: one monitorResources: true samples each run's CPU time and peak memory across its whole process tree, live and per run, in the dashboard, the metrics, and the failure reports (see Resource monitoring)
A job-set id: an order-independent fingerprint of every job's effective configuration, so replicas deployed from the same config can confirm they hold an identical set of jobs (see Job-set id)
Opt-in clustering and leader election: optionally have instances confirm over mutual TLS that a configured set of peers is running the same job set, and elect a leader so several replicas can run from one config without double-running jobs (see Clustering and leader election)
Arbitrary timezone support
Optional live control panel: watch every job's status, tail its logs in real time, run or cancel jobs on demand, review run history and success rates, drive DAG runs and approvals, and keep an eye on the whole cluster, from one self-contained page with ten themes and a shortcut for everything and a terminal twin (cronstable tui) with the same keys

pip install cronstable

jobs:
  - name: hello
    command: echo "hello from cronstable on $(hostname)"
    schedule: "* * * * *"        # every minute
    captureStdout: true

web:
  listen:
    - http://127.0.0.1:8080      # optional: the REST API + dashboard

cronstable -c cronstable.yaml

docker run --rm \
  -v "$PWD/cronstable.yaml:/etc/cronstable.d/cronstable.yaml:ro" \
  ghcr.io/ptweezy/cronstable:latest

pip install cronstable   # inside a venv
pipx install cronstable  # or isolated, via pipx

brew install ptweezy/tap/cronstable  # macOS or Linux, from the cronstable tap
winget install ptweezy.cronstable    # Windows

# pick the asset for your OS and architecture (glibc amd64 Linux shown; append
# -musl on Alpine, or use cronstable-macos- on a Mac)
curl -fsSL -o cronstable \
  https://github.com/ptweezy/cronstable/releases/latest/download/cronstable-linux-amd64
chmod +x cronstable
./cronstable --version

Default config location. When -c is omitted, cronstable looks in the machine-wide %ProgramData%\cronstable (the Windows analog of /etc/cronstable.d) whenever that directory holds configuration, and otherwise in the per-user %APPDATA%\cronstable (e.g. C:\Users\you\AppData\Roaming\cronstable). cronstable init writes a commented starter configuration into the default location, and -c points anywhere:
```
cronstable -c C:\path\to\cronstable.yaml
```
Default shell. A string command with no explicit shell runs through the native command processor (%ComSpec%, i.e. cmd.exe), mirroring the /bin/sh default on POSIX. shell: cmd and shell: powershell both work as written (cronstable gives cmd.exe the /c invocation and quoting it expects, and every other shell -c). For PowerShell, or any other interpreter, set shell: or pass command as a list (which bypasses the shell entirely):
```
jobs:
  - name: powershell-job
    command:
      - powershell
      - -Command
      - Get-Date
    schedule: "*/5 * * * *"
    captureStdout: true
```
Graceful shutdown. Press Ctrl-C to stop cronstable; it shuts down after the currently running jobs finish, just as SIGTERM does on POSIX (each job runs in its own console process group, so the keystroke never reaches the jobs themselves). Closing the console window and OS shutdown trigger the same drain on the OS's few seconds of grace, and the authenticated POST /shutdown route stops a console-less daemon (and stops the Windows service cleanly, without tripping its recovery actions). Logging off does not stop it: an unattended daemon sees that event for every user on the machine.
Running unattended, as a real Windows service. cronstable service install -c C:\ProgramData\cronstable registers the scheduler with the Service Control Manager, so it starts at boot, runs whether or not anyone is logged on, appears in services.msc, and gets Windows' own recovery actions; stopping it drains running jobs first, and the SCM is told the stop is still in progress for as long as that takes. It is a ctypes shim over advapi32, so it adds no dependency. The published one-file .exe cannot host a service (its bootloader runs the program in a child process the SCM never sees) and install says so; install with pip or pipx for that, or use the schtasks recipe. See Windows Service and Running on Windows.
Migrating from Task Scheduler. cronstable import-taskscheduler tasks.xml -o jobs.yaml converts an estate's exports into cronstable jobs, mapping time, calendar and boot triggers, Exec actions, working directories, execution time limits, instance policy and priority. It is a one-shot converter, not a loader, because exporting a task does not unregister it. Everything it cannot carry across is listed with a reason rather than dropped, and on a whole-machine export that list is long: most registered tasks on a stock Windows install are COM-handler or event-driven internals rather than schedules. See Importing from Task Scheduler.
Not supported on Windows. Per-job user/group switching (there is no setuid/setgid equivalent) is rejected with a clear configuration error, and unix:// web listeners are skipped with a warning. Use an http:// listener instead.

Live log tail	Run history	Schedule, explained

Follow a running job's output live over Server-Sent Events, with ANSI color, in-log grep (plain text or regex), per-line timestamps, line-wrap, and one-click download.	Success rate plus average / min / max duration over the retained history, with a color-coded per-run chart; with resource monitoring on, CPU time and peak memory per run and in the stats.	A plain-English reading of the cron expression and a timezone-aware preview of the next run times, computed live in the browser.

The task graph	A human approval gate

A `data-quality-gate` diamond: fan-out checks that reconverge on a `certify` task, colored by state as the run advances.	A release train parked on a human: the build succeeded, the approval gate is `awaiting`, and the sensor and publish tasks queue behind your decision.

Cluster panel	Fleet view

Nine nodes, `8/8 agreed`, quorum met, per-node load meters and per-node owns counts under `distribution: spread`.	Every node's state for every job, one glance: ok / failing / running cells with ages, per-column node health, and a failing only filter.

Incident timeline	Merged multi-tail

"What happened, in what order": relative times, outcome glyphs, failure reasons, exit codes, durations, and a failing only filter.	Four streams, one pane: identity-colored prefixes, `end of run output` markers, auto re-attach on each job's next run.

jobs:
  - name: nightly-backup
    command: /usr/local/bin/backup --incremental
    schedule: "0 3 * * *"
    captureStderr: true            # include stderr in the report
    onFailure:
      retry:
        maximumRetries: 5
        initialDelay: 5            # 5s, 10s, 20s, 40s, ... capped at 300s
        maximumDelay: 300
        backoffMultiplier: 2
    onPermanentFailure:            # fires once, after the last retry is spent
      report:
        webhook:
          url:
            fromEnvVar: SLACK_WEBHOOK_URL

state:
  path: /var/lib/cronstable           # a local dir, or a shared mount for a fleet

jobs:
  - name: hourly-invoice-emit
    command: python -m billing.emit_hourly
    schedule: "0 * * * *"
    onMissed: run-all              # replay each hour missed while we were down
    startingDeadlineSeconds: 21600 # ...unless the slot is older than 6h
    onFailure:
      retry:
        maximumRetries: 10
        initialDelay: 30
        maximumDelay: 600
        backoffMultiplier: 2

state:
  path: /var/lib/cronstable           # DAGs live on the state store

dags:
  - name: release-train            # no schedule: manual-only
    tasks:
      - id: build
        command: make dist
      - id: approve
        type: approval             # parks the graph on a human decision
        dependsOn: [build]
      - id: publish
        dependsOn: [approve]
        command: make publish
        retries: 2                 # task-level retries, DAG-owned
        retryDelaySeconds: 60

curl -X POST http://127.0.0.1:8080/dags/release-train/trigger
# -&gt; {"dag": "release-train", "runKey": "manual-..."}
curl -X POST http://127.0.0.1:8080/dags/release-train/runs//tasks/approve/decision \
     -H 'Content-Type: application/json' -d '{"decision": "approve", "by": "alice"}'

state:
  path: /mnt/shared/cronstable/state  # shared durable state (optional but natural here)

cluster:
  backend: filesystem
  filesystem:
    path: /mnt/shared/cronstable      # the mount is the election store
  nodeName: node-a                 # unique and stable per replica!
  electLeader: true

jobs:
  - name: charge-subscriptions
    command: python -m billing.charge
    schedule: "0 6 * * *"
    clusterPolicy: Leader          # the default: exactly the leader runs it

Example	One command	Shows off
`demo`	`docker compose up`	The dashboard playground: varied jobs, live logs, retries, a long-runner, an on-demand job.
`grand-tour`	`docker compose -f example/grand-tour/docker-compose.yml up --build`	Everything at once: a 9-node mTLS cluster, shared durable state, five DAG patterns, second-level probes, all five cross-platform reporters wired to live sinks.
`cluster`	`docker compose -f example/cluster/docker-compose.yml up`	A 3-node gossip cluster: peer attestation, quorum, leader election, live failover.
`cluster-large`	`docker compose -f example/cluster-large/docker-compose.yml up`	A 10-node, CPU-heavy fleet for watching `distribution: spread` and the load meters.
`dag`	`cronstable -c example/dag`	Orchestration alone, single node: dependencies, XCom, fan-out, a sensor, an approval gate.
`dag-cluster`	`docker compose -f example/dag-cluster/docker-compose.yml up`	DAGs coordinating across three nodes on one shared store: crash-resume, exactly-once tasks.
`job-state`	`cronstable -c example/job-state`	The job-facing state primitives: KV, cursors, locks, idempotency keys, artifacts, secrets.
`mcp`	`docker compose -f example/mcp/docker-compose.yml up --build`	The MCP server: an AI agent (Claude, Cursor, Copilot) observing and driving the scheduler over `POST /mcp`, or the `cronstable mcp` stdio bridge.
`pulse-monitor`	`docker compose -f example/pulse-monitor/docker-compose.yml up`	Second-level scheduling as a real-time uptime / SLA monitor.
`pulse-cluster`	`docker compose -f example/pulse-cluster/docker-compose.yml up`	The same probes fanned across a 3-node leader-electing cluster.
`zen-demo`	`docker compose -f example/zen-demo/docker-compose.yml up`	A deliberately calm board, for the wallboard's zen screensaver.
`crontab`	`cronstable -c example/crontab`	Classic Vixie crontabs running as-is next to YAML jobs.
`kubernetes`	`kubectl apply -f example/kubernetes/deployment.yaml`	Leader election through a `coordination.k8s.io/v1` Lease.
`etcd`	`docker compose -f example/etcd/docker-compose.yml up`	Leader election through an etcd lease, over plain HTTP.
`docker`	`docker build`	The minimal "add cronstable to your own image" recipe.

cronstable -c /tmp/my-crontab.yaml

jobs:
  - name: test-01
    command: echo "foobar"
    shell: /bin/bash
    schedule: "*/5 * * * *"

jobs:
  - name: test-01
    command:
      - echo
      - foobar
    schedule: "*/5 * * * *"

jobs:
  - name: test-01
    command: echo "foobar"
    schedule:
      minute: "*/5"
      dayOfMonth: 19
      month: 7
      year: 2017
      dayOfWeek: "*"

jobs:
  - name: every-15s-string
    command: echo "tick"
    schedule: "*/15 * * * * * *"   # 7 fields: the leading field is seconds
  - name: every-15s-object
    command: echo "tick"
    schedule:
      second: "*/15"

jobs:
  - name: test-01
    command: echo "hello"
    schedule: "27 19 * * *"
    utc: false
    captureStdout: true

jobs:
  - name: test-01
    command: echo "hello"
    schedule: "27 19 * * *"
    timezone: America/Los_Angeles
    captureStdout: true

jobs:
  - name: test-01
    command: echo "foobar"
    shell: /bin/bash
    schedule: "*/5 * * * *"
    environment:
      - key: PATH
        value: /bin:/usr/bin

jobs:
  - name: test-01
    command: echo "foobar"
    shell: /bin/bash
    schedule: "*/5 * * * *"
    env_file: .env

SHELL=/bin/bash
PATH=/usr/local/bin:/usr/bin:/bin

# m h dom mon dow command
*/15 * * * *  /usr/local/bin/backup --incremental
30 4 * * mon-fri  /usr/local/bin/report --daily
@daily  /usr/local/bin/rotate-logs
0 0 * * *  pg_dump mydb &gt; /backup/mydb-$(date +\%F).sql

defaults:
    environment:
      - key: PATH
        value: /bin:/usr/bin
    shell: /bin/bash
    utc: false
jobs:
  - name: test-01
    command: echo "foobar"  # runs with /bin/bash as shell
    schedule: "*/5 * * * *"
  - name: test-02  # runs with /bin/sh as shell
    command: echo "zbr"
    shell: /bin/sh
    schedule: "*/5 * * * *"

- name: test-01
  command: |
    echo "hello" 1&gt;&amp;2
    exit 10
  schedule:
    minute: "*/2"
  captureStderr: true
  onFailure:
    report:
      sentry:
        dsn:
          fromEnvVar: SENTRY_DSN
      mail:
        from: example@foo.com
        to: example@bar.com
        smtpHost: 127.0.0.1
        subject: Cron job '{{name}}' failed
        body: |
          {{stderr}}
          (exit code: {{exit_code}})
      shell:
        shell: /bin/bash
        command: echo "Error code $CRONSTABLE_RETCODE"
      webhook:
        url:
          fromEnvVar: SLACK_WEBHOOK_URL

push:
  relay:
    url: https://relay.example.net/v1/notify
  devicesFile: /var/lib/cronstable/devices.json

defaults:
  onFailure:
    report:
      push:
        enabled: true

$ curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
    -d '{"name": "my-iphone", "platform": "ios", "publicKey": "", "pushToken": ""}' \
    http://127.0.0.1:8080/push/devices

defaults:
  onFailure:
    report:
      eventlog:
        enabled: true

Get-WinEvent -FilterHashtable @{ LogName = 'Application'; ProviderName = 'cronstable'; ID = 1001, 1002 }

web:
  listen:
    - http://127.0.0.1:8080

jobs:
  - name: test01
    command: echo "hello"
    schedule: "* * * * *"
    statsd:
      host: my-statsd.example.com
      port: 8125
      prefix: my.cron.jobs.prefix.test01

my.cron.jobs.prefix.test01.start:1|g  # this one is sent when the job starts
my.cron.jobs.prefix.test01.stop:1|g   # the rest are sent when the job stops
my.cron.jobs.prefix.test01.success:1|g
my.cron.jobs.prefix.test01.duration:3|ms

jobs:
  - name: nightly-model-refresh
    command: python -m models.refresh
    schedule: "0 4 * * *"
    monitorResources: true

- name: test-01
  command: |
    echo "hello" 1&gt;&amp;2
    exit 10
  schedule:
    minute: "*/10"
  captureStderr: true
  onFailure:
    retry:
      maximumRetries: 10
      initialDelay: 1
      maximumDelay: 30
      backoffMultiplier: 2
  onPermanentFailure:
    report:
      mail:
        from: example@foo.com
        to: example@bar.com
        smtpHost: 127.0.0.1

- name: nightly-etl
  command: python -m etl.run
  schedule: "0 4 * * *"
  sla:
    maxTimeSinceSuccessSeconds: 129600   # no success for 36h
    lateAfterSeconds: 900                # a due slot not started within 15min
    maxRuntimeSeconds: 7200              # a run still going after 2h
  onLate:
    report:
      webhook:
        url:
          fromEnvVar: SLACK_WEBHOOK_URL

- name: test-03
  command: |
    echo "starting..."
    sleep 2
    echo "all done."
  schedule:
    minute: "*"
  captureStderr: true
  executionTimeout: 1  # in seconds

- name: test-03
  command: |
    trap "echo '(ignoring SIGTERM)'" TERM
    echo "starting..."
    sleep 10
    echo "all done."
  schedule:
    minute: "*"
  captureStderr: true
  executionTimeout: 1
  killTimeout: 0.5

- name: test-03
  command: id
  schedule:
    minute: "*"
  captureStderr: true
  user: www-data

- name: nightly-import
  command: import.bat
  schedule:
    minute: "0"
    hour: "2"
  workingDirectory: C:\jobs\importer

- name: nightly-reindex
  command: reindex.sh
  schedule:
    minute: "0"
    hour: "3"
  priority: idle

web:
  listen:
     - http://127.0.0.1:8080
     - unix:///tmp/cronstable.sock

$ http post http://127.0.0.1:8080/jobs/test-02/pause durationSeconds:=7200 note="db migration"
HTTP/1.1 200 OK

{"paused": {"since": "2026-07-19T14:00:00+00:00", "until": "2026-07-19T16:00:00+00:00", "note": "db migration", "by": "api", "channel": "api"}}

web:
  listen:
     - http://127.0.0.1:8080                      # loopback, plaintext
     - https://0.0.0.0:8443                       # served with the material below
  tls:
    cert: /etc/cronstable/web.pem
    key:  /etc/cronstable/web.key
    clientCa: /etc/cronstable/callers-ca.pem      # optional: require client certs

CLI: print it and exit (handy in scripts / health checks):

$ cronstable -c /etc/cronstable.d --job-set-id
v1:b834d7565aee0da50cd017f666651a5ba3b2e6b161daf0cb6e430f23f51ce90b

HTTP: GET /job-set-id on the web interface (also application/json), and shown in the dashboard header:

$ http get http://127.0.0.1:8080/job-set-id
v1:b834d7565aee0da50cd017f666651a5ba3b2e6b161daf0cb6e430f23f51ce90b

$ http get http://127.0.0.1:8080/job-set-id Accept:application/json
{"job_set_id": "v1:b834d7…51ce90b", "jobs": 3}

Logs: it is logged once at startup, and again whenever a config reload changes it.

cluster:
  listen: "0.0.0.0:8443"          # the mTLS listener for this node
  tls:
    ca:   /etc/cronstable/cluster-ca.pem   # trust anchor for peer certificates
    cert: /etc/cronstable/this-node.pem    # this node's certificate
    key:  /etc/cronstable/this-node.key
  peers:
    - host: cronstable-b.internal:8443
    - host: cronstable-c.internal:8443
  nodeName: cronstable-a              # optional; defaults to the system hostname
  interval: 30                    # optional; seconds per round (default 30)
  connectTimeout: 10              # optional; per-peer connect timeout (default 10)
  driftAfter: 3                   # optional; rounds before "drifted" (default 3)
  electLeader: true               # observe-only if false (the default)

include:
  - _inc.yaml

jobs:

  - name: my job
    ...

defaults:
  shell: /bin/bash
  onPermanentFailure:
    report:
      sentry:
        ...

web:
  listen:
    - "0.0.0.0:${WEB_PORT:-8080}"   # port from the environment, default 8080
state:
  path: ${STATE_DIR}               # required: unset fails --validate-config
jobs:
  - name: rollup-${REGION}
    command: run-rollup             # ${VAR} in a command is left for the shell
    schedule:
      minute: "0"
    timezone: ${TZ:-UTC}

logging:
  # In the format of:
  # https://docs.python.org/3/library/logging.config.html#dictionary-schema-details
  version: 1
  disable_existing_loggers: false
  formatters:
    simple:
      format: '%(asctime)s [%(processName)s/%(threadName)s] %(levelname)s (%(name)s): %(message)s'
      datefmt: '%Y-%m-%d %H:%M:%S'
  handlers:
    console:
      class: logging.StreamHandler
      level: DEBUG
      formatter: simple
      stream: ext://sys.stdout
  root:
    level: INFO
    handlers:
      - console

jobs:
  - name: test-01
    enabled: false  # this cron job will not run until you change this to `true`
    command: echo "foobar"
    shell: /bin/bash
    schedule: "* * * * *"

cronstable ptweezy

README

cronstable™

Why cronstable?

Features

Quick start

Installation

Run with Docker

Install using pip

Install using Homebrew or winget

Install using binary

Running on Windows

Production container deployment

Web dashboard

Orchestration, live

The whole fleet on one page

When things break

Wallboards, heatmaps, and the state store

Themes, Readability, and Accessibility

Terminal dashboard

Tutorials

Tutorial 1: Alert when a job fails, then retry it

Tutorial 2: Survive restarts, catch up what was missed

Tutorial 3: Your first DAG, a durable pipeline

Tutorial 4: Two replicas, zero double-runs

Example gallery

Usage

Configuration basics

Schedule introspection

Second-level schedules

Classic crontab files

Specifying defaults

Reporting

Push notifications

Windows Event Log

Metrics

Resource monitoring

Handling failure

Late-run detection (SLA monitoring)

Concurrency

Execution timeout

Change to another user/group

Working directory

Process priority

Remote web/HTTP interface

Serving the API over TLS

Job-set id

Clustering and leader election

Includes

Environment variable interpolation

Custom logging

Obscure configuration options

enabled: true|false (default true)

Performance

Documentation map

Contributing and license