jdx/mise · error

brew-cask: : unsupported step type

Error message

brew-cask:{}: unsupported {kind} step type {}

What it means

The catch-all arm of parse_flight_step. Each step object in preflight_steps/postflight_steps needs a "type", and mise implements exactly six: move, remove, copy, symlink, run, terminate_process. Any other type string — e.g. set_permissions, delete, launchctl — is unsupported and fails the whole cask parse with the cask token and offending type in the message.

Solutions

  1. Replace the unsupported step with one of the implemented types (move, remove, copy, symlink, run, terminate_process) if the effect can be expressed that way
  2. Update mise — new step types are added over time; retest after upgrading
  3. Otherwise install the cask with native brew instead of mise and report the cask token to the mise issue tracker

Example fix

// before
{"steps": [{"type": "set_permissions", "path": "bin/tool", "mode": "755"}]}
// after
{"steps": [{"type": "run", "command": {"path": "chmod", "args": ["755", "bin/tool"]}}]}
Defensive patterns

Strategy: validation

Validate before calling

const SUPPORTED_STEP_TYPES: &[&str] = &["move", "remove", "copy", "symlink", "run", "terminate_process"];

fn flight_steps_ok(v: &serde_json::Value, kind: &str) -> bool {
    let Some(groups) = v.get(kind).and_then(|g| g.as_array()) else { return true; };
    groups.iter().all(|g| g.get("steps").and_then(|s| s.as_array()).map(|steps| {
        steps.iter().all(|s| {
            s.get("type").and_then(|t| t.as_str())
                .map(|t| SUPPORTED_STEP_TYPES.contains(&t))
                .unwrap_or(false)
        })
    }).unwrap_or(false))
}

Type guard

fn is_supported_step_type(v: &serde_json::Value) -> bool {
    v.as_str().map(|t| ["move", "remove", "copy", "symlink", "run", "terminate_process"].contains(&t)).unwrap_or(false)
}

Try / catch

match parse_flight_steps(&cask, &artifact, kind) {
    Ok(steps) => { /* proceed */ }
    Err(e) if e.to_string().contains("step type") => {
        eprintln!("cask {} uses a flight step type mise does not implement; update mise or use brew directly", cask.token);
    }
    Err(e) => return Err(e),
}

Prevention

When it happens

Trigger: {"type": "set_permissions", ...} or any unrecognized type string inside a steps array of preflight_steps/postflight_steps; also triggered by step objects whose type key is present but names a Homebrew feature mise has not implemented.

Common situations: Homebrew casks using newer or rarer flight features (permissions, launchd management) that mise's Rust parser has not implemented yet; hand-written steps inventing types; version skew between Homebrew metadata and mise.

Related errors

AI-assisted analysis of jdx/mise@6f52dcdf99 (2026-08-22). Data as JSON: /api/errors/7bc07ba48255fc80. Report an issue: GitHub.

Appendix: source

Thrown at src/system/packages/brew/cask.rs:5787

            let failure_message = match object.get("failure_message") {
                None | Some(Value::Null) => None,
                Some(Value::String(value)) => Some(value.clone()),
                Some(_) => bail!(
                    "brew-cask:{}: {kind} terminate_process failure_message must be a string",
                    cask.token
                ),
            };
            Ok(FlightStep::TerminateProcess {
                name: name.to_string(),
                match_mode,
                sudo,
                attempts,
                must_succeed,
                notices,
                failure_message,
            })
        }
        _ => bail!(
            "brew-cask:{}: unsupported {kind} step type {}",
            cask.token,
            step_type
        ),
    }
}

fn parse_flight_sudo(cask: &Cask, kind: &str, value: Option<&Value>) -> Result<FlightSudo> {
    match value {
        None | Some(Value::Bool(false)) => Ok(FlightSudo::Never),
        Some(Value::Bool(true)) => Ok(FlightSudo::Always),
        Some(Value::String(value)) if value == "if_needed" => Ok(FlightSudo::IfNeeded),
        _ => bail!("brew-cask:{}: unsupported {kind} sudo setting", cask.token),
    }
}

fn parse_flight_guards(cask: &Cask, kind: &str, value: Option<&Value>) -> Result<Vec<FlightGuard>> {
    value

View on GitHub (pinned to 6f52dcdf99)