Overview

WolfFlow is WolfStack’s visual workflow automation engine. It lets you design multi-step runbooks in a drag-and-drop editor, schedule them with cron expressions, and execute them across your entire infrastructure — all from the WolfStack dashboard.

Think of it as n8n or Rundeck built directly into your server management platform. No external dependencies, no separate services to install — WolfFlow runs inside WolfStack and has full access to every node, container, and VM in your cluster.

Key Features

• Visual workflow editor — Drag-and-drop canvas with a toolbox of built-in actions, step-by-step flow, and per-step configuration
• 18 built-in action types — Update packages, update WolfStack, restart services, run shell commands, clean logs, check disk space, restart containers, Docker prune, HTTP requests, Docker image updates, NetBird management, TrueNAS snapshots, Unifi device control, conditional branching, AI Invoke (ask the configured AI model a question mid-workflow), Agent Chat (message a named WolfAgent with persistent memory and tools), and more
• Flexible targeting — Execute on a single node, all nodes, a specific cluster, hand-picked nodes, individual containers/VMs, or everything (all nodes + all their containers and VMs)
• Cron scheduling — Full 5-field cron expressions with quick presets (daily, hourly, weekly, etc.) or manual-only execution
• Parallel cross-node execution — Steps run on all target nodes simultaneously, with results collected per-node before moving to the next step
• Structured outputs & data passing — Each action produces structured key-value data (not just text). Use {{step_name.key}} to reference previous step outputs in downstream steps
• Conditional branching — If/Else nodes evaluate expressions and jump to different steps based on the result. Build real decision logic into your workflows
• Output reference picker — When editing a Condition, the UI shows clickable {{step_name.key}} references from all previous steps — no need to remember field names
• Retry logic — Configure per-step retry count and delay. Failed steps are automatically retried before triggering the failure policy
• Workflow timeout — Set a maximum runtime for the entire workflow. If exceeded, the workflow aborts cleanly
• 5 failure policies — Abort, Continue, Alert, Notify & Abort, Notify & Continue — with alerting integration (email, Discord, Slack, Telegram)
• Email notifications — Get HTML-formatted results emails with step-by-step output when workflows complete
• Per-step target overrides — Run most steps on all nodes but target a specific container for one step
• Infrastructure explorer — Browse your entire cluster tree (nodes, Docker containers, LXC containers, Proxmox VMs) when selecting targets
• Execution history — Full run logs with per-node, per-step status, duration, and output

The Visual Editor

WolfFlow’s editor is a three-panel layout designed for fast workflow creation:

Left Panel — Toolbox

22 action cards organised by category (System, Docker, Integration, Logic, Services), each colour-coded by type. Click or drag an action to add it as a new step in your workflow.

Centre Panel — Canvas

Your workflow is displayed as a vertical flow of step cards connected by arrows. Each card shows the step name, action type, and target scope. Click the + button between steps to insert a new step, or drag from the toolbox to reorder. Click any step to select it and edit its properties.

Right Panel — Properties

When a step is selected, the properties panel shows:

• Step name — Editable label for the step
• Action type — Change the action (parameters update automatically)
• Action-specific fields — Text inputs, dropdowns, number fields depending on the action
• On failure policy — Continue, Abort, or Alert
• Target override — Optionally override the workflow-level target for this step only

Toolbar

The toolbar across the top of the editor provides:

• Workflow name — Large editable text field
• Schedule — Cron expression input with quick preset buttons
• Enabled toggle — Enable or disable the workflow
• Email results — Optional email address for completion notifications
• Save and Run Now buttons

Action Types

WolfFlow includes 16 built-in actions that cover the most common infrastructure automation tasks:

Every action has built-in timeout protection and captures stdout/stderr output (up to 5,000 characters per step) for review in the execution history.

Template Variables

Steps can reference outputs from previous steps using the {{step_name.key}} syntax. This allows you to chain steps together — for example, check if a Docker image has an update, then use the result in a Condition step to decide whether to proceed with the update.

Step 1: Docker Update Check  (name: "Check Nginx")
         container_or_image: nginx

Step 2: Condition (If/Else)
         expression: {{Check Nginx.update_available}}
         operator: eq
         compare_to: true

Step 3: Docker Container Update  (only runs if Step 2 is true)
         container_name: nginx
         backup_first: true

Structured Outputs

Each action type produces structured key-value data that downstream steps can reference. For example:

Output Reference Picker

When editing a Condition (If/Else) step, the properties panel shows a clickable list of all available {{step_name.key}} references from previous steps. Click any reference to insert it into the expression field — no need to remember field names or type the template syntax manually.

Retry Logic

Each step can be configured with a retry count and retry delay. If a step fails, WolfFlow automatically retries it the specified number of times before triggering the failure policy. This is useful for flaky operations like network calls or external API requests.

Workflow Timeout

Set a maximum runtime (in seconds) on the workflow. If the total execution time exceeds this limit, WolfFlow aborts the workflow cleanly. Set to 0 for no limit.

Execution Targets

WolfFlow supports six targeting scopes. Set a default target at the workflow level, then optionally override it per step.

Execution Inside Containers & VMs

When targeting containers or VMs, WolfFlow executes commands inside the target, not on the host:

• Docker — commands run via docker exec <container> sh -c "..."
• LXC — commands run via lxc-attach -n <container> -- sh -c "..."
• VMs — commands run via SSH to the VM’s IP address (WolfNet IP or ARP-discovered)

Actions like Update Packages, Clean Logs, Check Disk Space, Restart Service, and Run Shell Command all work inside containers. The AI automatically adapts the command to the container’s environment.

Infrastructure Explorer

When selecting targets, click Set Target to open the infrastructure explorer. It displays your entire cluster tree with:

• All clusters and nodes with online/offline status
• Docker containers (blue icon) with running/stopped state
• LXC containers (green icon) with running/stopped state
• VMs (orange icon) with running/stopped state
• Multi-select checkboxes for picking exactly what you need

The infrastructure tree is cached for 60 seconds and refreshes automatically.

Scheduling

WolfFlow uses standard 5-field cron expressions (UTC) for scheduling:

minute  hour  day-of-month  month  day-of-week

Quick Presets

The editor includes one-click preset buttons for common schedules:

Cron Syntax

• * — Any value
• 5 — Specific value
• 1,15,30 — Multiple values
• 1-5 — Range
• */15 — Every N units
• 1-30/5 — Every 5th value in range 1–30
• Day-of-week: Sunday = 0 or 7, Monday = 1 … Saturday = 6

The built-in scheduler checks all enabled workflows every 60 seconds. Duplicate runs within the same minute are automatically prevented.

Failure Handling

Each step has an on-failure policy that controls what happens when the step fails on one or more target nodes:

When a workflow targets multiple nodes, each node executes independently. One node failing a step doesn’t prevent other nodes from completing that step — the failure policy determines whether the workflow continues to the next step.

Execution & Monitoring

How Workflows Execute

1. Trigger — A workflow runs either on its cron schedule or when you click Run Now
2. Resolve targets — WolfFlow resolves the target scope into a list of online nodes
3. Execute steps sequentially — Each step runs on all target nodes in parallel, then results are collected before the next step begins
4. Remote execution — For remote nodes, commands are sent via the WolfStack node proxy API with cluster secret authentication
5. Collect results — Each step records per-node status (success/failure), output, and duration
6. Email results — If an email address is configured, an HTML report is sent with a detailed step-by-step breakdown

Task Log Integration

Every workflow execution appears in WolfStack’s main task log with live progress updates. You can see:

• Which step is currently executing
• Per-node status with colour-coded badges (success, failed, running)
• Command output for each step
• Total duration and final status

Run History

WolfFlow keeps a history of the last 500 workflow runs. Each run record includes:

• Workflow name and run ID
• Trigger type (Manual or Scheduled)
• Start time and total duration
• Overall status (Completed, Failed, Partial Failure, Running)
• Per-step, per-node results with output

Email Notifications

When an email address is set on a workflow, WolfFlow sends an HTML-formatted results email after every run. The email includes:

• Status header — Workflow name, overall status (Completed/Failed/Partial Failure), and trigger type
• Duration — Total execution time
• Step table — Each step with target node hostname, status badge, duration, and command output (truncated to 500 characters per step)

Email uses the SMTP settings configured in Settings → AI Agent. Make sure SMTP is configured before enabling email notifications.

Example Workflows

Daily Fleet Maintenance

Schedule: 0 3 * * *  (Daily at 3 AM UTC)
Target:   All Nodes

Step 1: Check Disk Space        [on failure: Continue]
         warn_threshold_pct: 90
         mount_point: all

Step 2: Clean Journal Logs      [on failure: Continue]
         max_size_mb: 500

Step 3: Update System Packages  [on failure: Alert]

Step 4: Docker Prune            [on failure: Continue]

Email results to: admin@example.com

Staged WolfStack Update

Schedule: Manual only
Target:   Specific Nodes (staging-node-01)

Step 1: Update WolfStack        [on failure: Abort]
         channel: master

Step 2: Run Shell Command        [on failure: Abort]
         command: systemctl status wolfstack
         timeout_secs: 30

-- After verifying staging, run a second workflow
-- targeting production nodes

Container Lifecycle

Schedule: 0 2 * * 0  (Weekly, Sunday at 2 AM UTC)
Target:   Local

Step 1: Run Shell Command        [on failure: Abort]
         command: docker pull myapp:latest

Step 2: Restart Container        [on failure: Abort]
         runtime: docker
         name: myapp

Step 3: Run Shell Command        [on failure: Alert]
         command: curl -sf http://localhost:8080/health
         timeout_secs: 30

Multi-Cluster Health Check

Schedule: */15 * * * *  (Every 15 minutes)
Target:   All Nodes

Step 1: Check Disk Space        [on failure: Continue]
         warn_threshold_pct: 85
         mount_point: all

Step 2: Run Shell Command        [on failure: Continue]
         command: systemctl is-active docker || echo "Docker not running"

Email results to: oncall@example.com

REST API

WolfFlow exposes a full REST API for programmatic access:

All endpoints require a valid wolfstack_session cookie. Inter-node execution uses the X-WolfStack-Secret header for authentication.

Configuration & Persistence

WolfFlow stores all data as JSON files:

• /etc/wolfstack/wolfflow/workflows.json — All workflow definitions
• /etc/wolfstack/wolfflow/runs.json — Execution history (last 500 runs)

Data is loaded on startup and saved automatically after every create, update, delete, or run operation. The /etc/wolfstack/wolfflow/ directory is created automatically if it doesn’t exist.

Back up the /etc/wolfstack/wolfflow/ directory to preserve your workflows and run history.

WolfFlow vs. Cron Jobs

WolfStack already has a Cron Jobs page for managing system crontabs. WolfFlow is a higher-level tool that builds on top of that concept:

Use Cron Jobs for simple, single-node tasks. Use WolfFlow for multi-step, multi-node automation with visibility and failure handling.