otto-cli 0.1.0

Task runner with retries, timeouts, history, and notifications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

# Otto

[![check](https://github.com/mcmanussliam/otto/actions/workflows/check.yml/badge.svg)](https://github.com/mcmanussliam/otto/actions/workflows/check.yml)
[![release](https://img.shields.io/github/v/release/mcmanussliam/otto)](https://github.com/mcmanussliam/otto/releases)
[![crates.io](https://img.shields.io/crates/v/otto-cli.svg)](https://crates.io/crates/otto-cli)
[![license](https://img.shields.io/github/license/mcmanussliam/otto)](LICENSE)

Otto is a simple task runner. Think `make`, but with built-in retries, timeouts,
run history, and notifications.

```bash
% otto run -- echo "hello"

ok run "inline" finished in 3ms

% otto history

inline ok success
  source: inline
  exit: 0
  started (UTC): 2026-02-22 18:10:09
  duration: 3ms
```

## Install

Install from crates.io:

```bash
cargo install otto-cli --locked
otto version
```

## 60-second quick start

```bash
otto init
otto tasks
otto run -- echo "works"
```

Then add your own task to `otto.yml`:

```yaml
version: 1

defaults:
  timeout: "2m"
  retries: 0
  retry_backoff: "1s"
  notify_on: failure

notifications:
  desktop: true

tasks:
  test:
    description: run unit tests
    exec: ["cargo", "test"]
```

Run it:

```bash
otto run test
```

## How tasks work

Use exactly one command mode per task:

- `exec`: direct argv execution (no shell parsing)
- `run`: shell command (`/bin/sh -c` on macOS/Linux, `cmd /C` on Windows)
- `tasks`: compose other tasks by name

Task composition example:

```yaml
tasks:
  lint:
    exec: ["cargo", "fmt", "--all", "--check"]

  clippy:
    exec: ["cargo", "clippy", "--all-targets", "--all-features", "--", "-D", "warnings"]

  build:
    exec: ["cargo", "build", "--release"]

  ci:
    tasks: ["lint", "build", "clippy"]
    parallel: false # set true to run child tasks in parallel
```

Shared defaults live in `defaults`, and each task can override:

- `timeout`
- `retries` (0..10)
- `retry_backoff` (uses exponential backoff between attempts)
- `notify_on` (`never`, `failure`, `always`)

## Dotenv and env expansion

`otto run` auto-loads `.env` if present.

- Disable it: `--no-dotenv`
- Use a different file: `--env-file .env.staging`

Variables from process env + dotenv + task `env` are expanded in:

- `run`
- `exec` args
- `dir`
- `env` values

Unknown variables are preserved as `${NAME}`.

## Notifications

Supported channels:

- desktop (`osascript` on macOS, `notify-send` on Linux)
- webhook (`POST` JSON to `notifications.webhook_url`)

`notify_on` controls when notifications fire: `never`, `failure`, `always`.

## History and automation

Every run gets recorded in `.otto/history.jsonl`.

For scripts, use:

- `otto run --json`
- `otto tasks --json`
- `otto history --json`

In JSON mode, command output is suppressed so stdout is valid JSON only.

## Shell completion

```bash
otto completion bash
otto completion zsh
otto completion fish
otto completion powershell
```