### Install and Run Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Demonstrates how to run Kumacli without installation using `uvx` or install it globally with `pip`. Also shows local development setup.

```bash
# Run without installing (recommended)
uvx kumacli --help

# Install globally
pip install kumacli

# Local development
uv sync --all-groups
uv run kumacli --help
```

--------------------------------

### Install KumaCLI using uvx

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Run KumaCLI without installation using uvx. This is the default method.

```bash
uvx kumacli --help
```

--------------------------------

### Development Setup and Testing

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Commands for setting up the development environment and running tests using uv and pytest.

```bash
uv sync --all-groups
uv run pytest -q
```

--------------------------------

### Get Global Help

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Display help information for the main kumacli command and its subcommands.

```bash
uvx kumacli --help
uvx kumacli monitors --help
uvx kumacli maintenance --help
```

--------------------------------

### Install KumaCLI from PyPI

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Optionally install KumaCLI globally from the Python Package Index using pip.

```bash
pip install kumacli
```

--------------------------------

### Quick Start: Set Environment Variables and List Monitors

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Configure Uptime Kuma connection details via environment variables and then list all monitors in JSON format.

```bash
export KUMACLI_HOST="http://localhost:3001"
export KUMACLI_USERNAME="admin"
export KUMACLI_PASSWORD="secret"

uvx kumacli monitors list --json
```

--------------------------------

### Create a recurring weekly maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Set up a maintenance window that repeats weekly on a specified day, with defined start and end times and timezone.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create \
  --title "Weekly DB backup" \
  --strategy recurring-weekday \
  --weekday 0 \
  --time-start "02:00" \
  --time-end "04:00" \
  --timezone "Europe/Berlin" \
  --monitor-id 4 \
  --json
```

--------------------------------

### CI/CD Deployment Script Example

Source: https://context7.com/vedmaka/kumacli/llms.txt

A bash script demonstrating a typical CI/CD integration pattern. It pauses monitors, creates a maintenance window, deploys an application, resumes monitors, and cleans up the maintenance window. Uses environment variables for authentication and `jq` for parsing JSON output.

```bash
#!/usr/bin/env bash
# deploy.sh — pause monitors, deploy, create maintenance window, resume

set -euo pipefail

KUMA="--url $KUMACLI_HOST --username $KUMACLI_USERNAME --password $KUMACLI_PASSWORD"

echo "Pausing monitors..."
kumacli $KUMA monitors pause --id 1 --json
kumacli $KUMA monitors pause --id 2 --json

echo "Creating maintenance window..."
MAINT_ID=$(kumacli $KUMA maintenance create \
  --title "Deploy $(date -u +%Y-%m-%dT%H:%M)" \
  --strategy single \
  --date-start "$(date -u '+%Y-%m-%d %H:%M')" \
  --date-end "$(date -u -d '+2 hours' '+%Y-%m-%d %H:%M')" \
  --monitor-id 1,2 \
  --json | jq -r '.maintenance_id')

echo "Deploying application..."
# ... your deploy steps here ...

echo "Resuming monitors..."
kumacli $KUMA monitors resume --id 1 --json
kumacli $KUMA monitors resume --id 2 --json

echo "Cleaning up maintenance window..."
kumacli $KUMA maintenance delete --id "$MAINT_ID" --json

echo "Done."
```

--------------------------------

### Kumacli .env Configuration

Source: https://context7.com/vedmaka/kumacli/llms.txt

Example of a `.env` file used for configuring Kumacli connection details like host, username, password, timeout, and TLS verification.

```ini
# .env
KUMACLI_HOST=http://localhost:3001
KUMACLI_USERNAME=admin
KUMACLI_PASSWORD=change-me
KUMACLI_TIMEOUT=10
KUMACLI_INSECURE=false
```

--------------------------------

### Handle maintenance create error for unknown monitor ID

Source: https://context7.com/vedmaka/kumacli/llms.txt

This example shows how the CLI validates monitor IDs during creation and fails fast if unknown IDs are provided.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create --title "Test" --monitor-id 999
```

--------------------------------

### Get Specific Monitor Details

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Retrieve detailed information for a specific monitor by its ID, with output formatted as JSON. Requires authentication credentials.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" monitors get --id 1 --json
```

--------------------------------

### monitors get

Source: https://context7.com/vedmaka/kumacli/llms.txt

Retrieves the full configuration object for a specific monitor by its numeric ID.

```APIDOC
## monitors get

### Description
Retrieve the full configuration object for a specific monitor by its numeric ID.

### Method
GET (implied)

### Endpoint
/api/monitors/{id} (implied)

### Parameters
#### Global Connection Flags
- `--url` / `--host` (string) - Required - Uptime Kuma base URL
- `--username` (string) - Required - Login username
- `--password` (string) - Required - Login password
- `--timeout` (integer) - Optional - API timeout in seconds (default: 10)
- `--insecure` (boolean) - Optional - Disable TLS certificate verification (default: false)

#### Command Flags
- `--id` (integer) - Required - The numeric ID of the monitor to retrieve.
- `--json` (boolean) - Optional - Output in JSON format

### Request Example
```bash
kumacli --url http://localhost:3001 --username admin --password secret monitors get --id 1 --json
```

### Response
#### Success Response (200)
- `id` (integer) - The unique identifier for the monitor.
- `name` (string) - The name of the monitor.
- `type` (string) - The type of monitor.
- `url` (string) - The URL or hostname being monitored.
- `interval` (integer) - The interval in seconds for checking the monitor.
- `active` (boolean) - Indicates if the monitor is currently active.
- `maxretries` (integer) - The maximum number of retries before marking as down.
- `retryInterval` (integer) - The interval in seconds between retries.
- ... (other configuration fields)

#### Response Example
```json
{
  "id": 1,
  "name": "Main API",
  "type": "http",
  "url": "https://example.com/health",
  "interval": 60,
  "active": true,
  "maxretries": 3,
  "retryInterval": 30
}
```
```

--------------------------------

### Handle monitor update errors

Source: https://context7.com/vedmaka/kumacli/llms.txt

This example shows an error case where no update fields are provided for a monitor. The CLI will return an error and a non-zero exit code.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors update --id 1
```

--------------------------------

### Add HTTP Monitor with Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Example of adding a new HTTP monitor using Kumacli, specifying URL, interval, and retry settings via `--field` flags. Output is JSON.

```bash
# HTTP monitor with interval and retry settings via --field
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors add \
  --name "Payment API" \
  --type http \
  --field "url=https://api.example.com/health" \
  --field "interval=60" \
  --field "maxretries=3" \
  --field "retryInterval=30" \
  --json
```

--------------------------------

### Create Maintenance Window: Single Strategy

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a one-time maintenance window with a specific start and end date and time. This is suitable for scheduled, non-recurring events.

```bash
kumacli ... maintenance create --title "Deploy" --strategy single \
  --date-start "2026-08-01 20:00" --date-end "2026-08-01 22:00" --monitor-id 1
```

--------------------------------

### Get a specific maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Fetch the complete configuration details for a single maintenance window using its ID.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance get --id 5 --json
```

--------------------------------

### Get Specific Monitor Details with Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Retrieves the full configuration object for a specific monitor by its numeric ID using Kumacli, with JSON output.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors get --id 1 --json
```

--------------------------------

### Update Monitor Fields with Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Example of updating fields on an existing monitor using Kumacli, specifying the monitor ID and the fields to update via `--field` flags. Output is JSON.

```bash
# Update retry count
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors update --id 1 \
  --field "maxretries=5" \
  --json
```

--------------------------------

### maintenance get

Source: https://context7.com/vedmaka/kumacli/llms.txt

Retrieve the full configuration of a specific maintenance window by its ID. This command is useful for inspecting the detailed settings of a maintenance period.

```APIDOC
## maintenance get

Retrieve the full configuration of a maintenance window by ID.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance get --id 5 --json

# Expected output:
# {
#   "id": 5,
#   "title": "Deploy window",
#   "status": "active",
#   "strategy": "manual",
#   ...
# }
```
```

--------------------------------

### List, Get, Pause, or Resume Maintenance Windows

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Manage maintenance windows by listing all, retrieving a specific one by ID, or changing its state to paused or resumed. All operations use JSON output.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance list --json
```

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance get --id 5 --json
```

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance pause --id 5 --json
```

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance resume --id 5 --json
```

--------------------------------

### Add Monitor from JSON File with Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Shows how to add a monitor by loading its configuration from a JSON file using `--data-file` and overriding specific fields with `--field` flags.

```bash
# Load full payload from a JSON file, then override a single field
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors add \
  --data-file ./monitor-template.json \
  --field "name=Staging API" \
  --json
```

--------------------------------

### Preflight Checks with kumacli

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Run these commands to ensure kumacli is set up correctly and to view help for its subcommands.

```bash
uv sync --all-groups
uv run kumacli --help
uv run kumacli monitors --help
uv run kumacli maintenance --help
```

--------------------------------

### List Monitors with Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Demonstrates listing all Uptime Kuma monitors using Kumacli. Shows both human-readable table output and JSON output suitable for scripting.

```bash
# Human-readable table
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors list

# JSON output (suitable for jq, scripts)
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors list --json

# Pipe to jq to filter only down monitors
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors list --json | jq '[.[] | select(.status == "down")]'
```

--------------------------------

### List Monitors with JSON Output

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Use this command to list all monitors with detailed JSON output. Ensure you provide the correct URL, username, and password.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" monitors list --json
```

--------------------------------

### Create Maintenance Window: Manual Strategy

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a maintenance window with a 'manual' strategy, which requires manual triggering and has no associated schedule.

```bash
kumacli ... maintenance create --title "Ad-hoc" --strategy manual --monitor-id 1
```

--------------------------------

### Add TCP Port Monitor with Kumacli

Source: https://context7.com/vedmaka/kumacli/llms.txt

Demonstrates adding a TCP port monitor using Kumacli, specifying hostname and port via `--field` flags. Output is JSON.

```bash
# TCP port monitor
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors add \
  --name "Postgres" \
  --type port \
  --field "hostname=db.internal" \
  --field "port=5432" \
  --json
```

--------------------------------

### Create a Maintenance Window

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Schedule a maintenance window with a title, strategy, date range, and associate it with specific monitors.

```bash
uvx kumacli maintenance create \
  --title "Deploy window" \
  --strategy single \
  --date-start "2026-03-01 22:00" \
  --date-end "2026-03-01 23:00" \
  --monitor-id 1 --monitor-id 2
```

--------------------------------

### Create a one-time maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Schedule a single maintenance window for a specific period, attaching multiple monitors by comma-separated IDs.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create \
  --title "v2.4.0 Deploy" \
  --strategy single \
  --date-start "2026-06-15 22:00" \
  --date-end "2026-06-15 23:30" \
  --monitor-id 1,2,3 \
  --json
```

--------------------------------

### Add Monitor with Layered Payload

Source: https://context7.com/vedmaka/kumacli/llms.txt

Demonstrates adding a monitor using a layered payload system. It shows how to combine a base template from a file, override settings with inline JSON, and further refine fields using the --field option. Later entries take precedence.

```bash
# Layer 1: base template from file
cat > base.json <<EOF
{
  "type": "http",
  "interval": 60,
  "maxretries": 3,
  "notificationIDList": [1]
}
EOF

# Layer 2: override via --data-json inline
# Layer 3: override specific field via --field
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors add \
  --data-file base.json \
  --data-json '{"interval": 30}' \
  --field "maxretries=5" \
  --name "Critical Service" \
  --json
# Result payload: {type:http, interval:30, maxretries:5, notificationIDList:[1], name:"Critical Service"}
```

```bash
# --field values auto-parse JSON scalars
#   interval=60   → integer 60
#   active=true   → boolean true
#   name=foo      → string "foo"
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors add \
  --name "Edge Cache" \
  --type http \
  --field "url=https://cdn.example.com" \
  --field "interval=120" \
  --field "active=true" \
  --field "maxretries=0" \
  --json
```

--------------------------------

### Kumacli Global Connection Flags

Source: https://context7.com/vedmaka/kumacli/llms.txt

Shows how to use global connection flags for Kumacli, overriding `.env` and environment variables. Demonstrates setting URL, username, password, timeout, and disabling insecure TLS verification.

```bash
# Flags override .env values at runtime
kumacli \
  --url http://kuma.internal:3001 \
  --username admin \
  --password secret \
  --timeout 30 \
  --no-insecure \
  monitors list --json
```

--------------------------------

### monitors add

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a new monitor with specified parameters.

```APIDOC
## monitors add

### Description
Create a new monitor. Requires `--name` and `--type`. Additional fields are supplied via `--field key=value` (repeatable), `--data-json`, or `--data-file`, merged in that priority order (file < json < field < explicit flags).

### Method
POST (implied)

### Endpoint
/api/monitors (implied)

### Parameters
#### Global Connection Flags
- `--url` / `--host` (string) - Required - Uptime Kuma base URL
- `--username` (string) - Required - Login username
- `--password` (string) - Required - Login password
- `--timeout` (integer) - Optional - API timeout in seconds (default: 10)
- `--insecure` (boolean) - Optional - Disable TLS certificate verification (default: false)

#### Command Flags
- `--name` (string) - Required - The name for the new monitor.
- `--type` (string) - Required - The type of monitor (e.g., "http", "port").
- `--field` (key=value pairs) - Optional - Specific fields to set for the monitor. Can be repeated.
- `--data-json` (string) - Optional - A JSON string representing the monitor configuration.
- `--data-file` (string) - Optional - Path to a JSON file containing the monitor configuration.
- `--json` (boolean) - Optional - Output in JSON format

### Request Example
```bash
# HTTP monitor with interval and retry settings via --field
kumacli --url http://localhost:3001 --username admin --password secret monitors add --name "Payment API" --type http --field "url=https://api.example.com/health" --field "interval=60" --field "maxretries=3" --field "retryInterval=30" --json

# TCP port monitor
kumacli --url http://localhost:3001 --username admin --password secret monitors add --name "Postgres" --type port --field "hostname=db.internal" --field "port=5432" --json

# Load full payload from a JSON file, then override a single field
kumacli --url http://localhost:3001 --username admin --password secret monitors add --data-file ./monitor-template.json --field "name=Staging API" --json
```

### Response
#### Success Response (200)
- `monitor_id` (integer) - The ID of the newly created monitor.
- `message` (string) - Confirmation message.

#### Response Example
```json
{"monitor_id": 7, "message": "Added Successfully."}
```
```

--------------------------------

### Create Maintenance Window: Recurring Interval Strategy

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a maintenance window that repeats every N days. Requires specifying the interval in days and the time range for the window.

```bash
kumacli ... maintenance create --title "Nightly check" --strategy recurring-interval \
  --interval-day 1 --time-start "01:00" --time-end "02:00" --monitor-id 2
```

--------------------------------

### Add a New Monitor

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Add a new monitor to Uptime Kuma with specified name, type, and configuration fields. Supports multiple fields and interval settings.

```bash
uvx kumacli monitors add \
  --name "Main API" \
  --type http \
  --field "url=https://example.com/health" \
  --field "interval=60"
```

--------------------------------

### Add a New Monitor

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Add a new monitor with specified name, type, and fields. The `--field` argument can be repeated for multiple configurations. JSON output is enabled.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" monitors add \
  --name "Main API" \
  --type http \
  --field "url=https://example.com/health" \
  --field "interval=60" \
  --json
```

--------------------------------

### Create a Maintenance Window

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Schedule a new maintenance window with a title, strategy, start/end times, and associated monitor IDs. JSON output is used for the operation.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance create \
  --title "Deploy window" \
  --strategy single \
  --date-start "2026-03-01 22:00" \
  --date-end "2026-03-01 23:00" \
  --monitor-id 1,2 \
  --json
```

--------------------------------

### Create Maintenance Window: Recurring Weekday Strategy

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a maintenance window that repeats on specified weekdays. Accepts multiple --weekday arguments (0=Sun to 6=Sat) and defines the time range.

```bash
kumacli ... maintenance create --title "Weekly" --strategy recurring-weekday \
  --weekday 1 --weekday 3 --time-start "03:00" --time-end "04:00" --monitor-id 3
```

--------------------------------

### Pause multiple monitors in a loop

Source: https://context7.com/vedmaka/kumacli/llms.txt

This script demonstrates how to pause several monitors efficiently by iterating through a list of IDs.

```bash
for id in 1 2 3; do
  kumacli --url http://localhost:3001 --username admin --password secret \
    monitors pause --id "$id" --json
done
```

--------------------------------

### List all maintenance windows

Source: https://context7.com/vedmaka/kumacli/llms.txt

Retrieve a list of all configured maintenance windows, including their ID, title, status, and scheduling strategy.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance list --json
```

--------------------------------

### Create Maintenance Window: Cron Strategy

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a maintenance window using a full cron expression for complex scheduling. Requires specifying the cron string, duration, and optionally timezone.

```bash
kumacli ... maintenance create --title "Cron job" --strategy cron \
  --cron "0 4 * * 1-5" --duration-minutes 45 --timezone "America/New_York" --monitor-id 5
```

--------------------------------

### Create a cron-based maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Define a maintenance window using a cron expression for precise scheduling, specifying duration and timezone.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create \
  --title "Nightly batch" \
  --strategy cron \
  --cron "0 3 * * *" \
  --duration-minutes 90 \
  --timezone "UTC" \
  --monitor-id 5 \
  --json
```

--------------------------------

### maintenance create

Source: https://context7.com/vedmaka/kumacli/llms.txt

Create a new maintenance window. You must provide a title and at least one monitor ID. This command supports various strategies like single, recurring-weekday, and cron.

```APIDOC
## maintenance create

Create a maintenance window and attach one or more monitors to it atomically. `--title` and at least one `--monitor-id` are required. Accepts comma-separated or repeated `--monitor-id` values. Unknown monitor IDs are validated and fail fast.

```bash
# One-time (single) maintenance window
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create \
  --title "v2.4.0 Deploy" \
  --strategy single \
  --date-start "2026-06-15 22:00" \
  --date-end "2026-06-15 23:30" \
  --monitor-id 1,2,3 \
  --json
# Output: {"maintenance_id": 12, "message": "Added Successfully.", "monitor_ids": [1, 2, 3]}

# Recurring weekly maintenance (Monday=1, Sunday=0)
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create \
  --title "Weekly DB backup" \
  --strategy recurring-weekday \
  --weekday 0 \
  --time-start "02:00" \
  --time-end "04:00" \
  --timezone "Europe/Berlin" \
  --monitor-id 4 \
  --json

# Cron-based maintenance
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create \
  --title "Nightly batch" \
  --strategy cron \
  --cron "0 3 * * *" \
  --duration-minutes 90 \
  --timezone "UTC" \
  --monitor-id 5 \
  --json

# Error: unknown monitor ID
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance create --title "Test" --monitor-id 999
# stderr: error: Unknown monitor IDs: 999
# exit code: 2
```
```

--------------------------------

### Create Maintenance Window: Recurring Day of Month Strategy

Source: https://context7.com/vedmaka/kumacli/llms.txt

Creates a maintenance window that repeats on specific days of the calendar month. Supports specifying exact days or using 'lastDay1' for the last day of the month.

```bash
kumacli ... maintenance create --title "Monthly" --strategy recurring-day-of-month \
  --day-of-month 1 --day-of-month lastDay1 \
  --time-start "00:00" --time-end "01:00" --monitor-id 4
```

--------------------------------

### Resume a monitor

Source: https://context7.com/vedmaka/kumacli/llms.txt

Re-enable monitoring for a previously paused monitor. This should be used after the reason for pausing is resolved.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors resume --id 1 --json
```

--------------------------------

### maintenance list

Source: https://context7.com/vedmaka/kumacli/llms.txt

List all maintenance windows with their ID, title, status, and strategy. This command provides a summary of all configured maintenance periods.

```APIDOC
## maintenance list

List all maintenance windows with ID, title, status, and strategy.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance list --json

# Expected output:
# [
#   {
#     "id": 5,
#     "title": "Deploy window",
#     "status": "under-maintenance",
#     "strategy": "single"
#   },
#   {
#     "id": 9,
#     "title": "Weekly DB backup",
#     "status": "active",
#     "strategy": "recurring-weekday"
#   }
# ]
```
```

--------------------------------

### monitors list

Source: https://context7.com/vedmaka/kumacli/llms.txt

Lists all monitors with their current status, active flag, and type. Output can be human-readable or JSON.

```APIDOC
## monitors list

### Description
List all monitors with their current status, active flag, and type. Without `--json`, output is tab-separated. With `--json`, output is a JSON array sorted by monitor ID.

### Method
GET (implied)

### Endpoint
/api/monitors (implied)

### Parameters
#### Global Connection Flags
- `--url` / `--host` (string) - Required - Uptime Kuma base URL
- `--username` (string) - Required - Login username
- `--password` (string) - Required - Login password
- `--timeout` (integer) - Optional - API timeout in seconds (default: 10)
- `--insecure` / `--no-insecure` (boolean) - Optional - Disable TLS certificate verification (default: false)

#### Command Flags
- `--json` (boolean) - Optional - Output in JSON format

### Request Example
```bash
kumacli --url http://localhost:3001 --username admin --password secret monitors list --json
```

### Response
#### Success Response (200)
- `id` (integer) - The unique identifier for the monitor.
- `name` (string) - The name of the monitor.
- `status` (string) - The current status of the monitor (e.g., "up", "down").
- `active` (boolean) - Indicates if the monitor is currently active.
- `type` (string) - The type of monitor (e.g., "http", "port").

#### Response Example
```json
[
  {
    "id": 1,
    "name": "Main API",
    "status": "up",
    "active": true,
    "type": "http"
  },
  {
    "id": 2,
    "name": "Database",
    "status": "down",
    "active": false,
    "type": "port"
  }
]
```
```

--------------------------------

### Pause, Resume, or Delete a Monitor

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Commands to manage the state of a monitor by its ID. Use `pause` to temporarily stop checks, `resume` to restart, and `delete` to remove it. JSON output is enabled.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" monitors pause --id 1 --json
```

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" monitors resume --id 1 --json
```

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" monitors delete --id 1 --json
```

--------------------------------

### Resume a maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Re-enable a paused maintenance window, allowing it to run as scheduled again. Use this after a pause is no longer necessary.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance resume --id 9 --json
```

--------------------------------

### Update only monitor links for a maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Change the monitors associated with a maintenance window without altering other settings like title or schedule.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance update --id 5 --monitor-id 2 --json
```

--------------------------------

### monitors update

Source: https://context7.com/vedmaka/kumacli/llms.txt

Updates fields on an existing monitor.

```APIDOC
## monitors update

### Description
Update fields on an existing monitor. At least one payload argument is required. Uses the same `--field`/`--data-json`/`--data-file` payload system as `add`.

### Method
PUT / PATCH (implied)

### Endpoint
/api/monitors/{id} (implied)

### Parameters
#### Global Connection Flags
- `--url` / `--host` (string) - Required - Uptime Kuma base URL
- `--username` (string) - Required - Login username
- `--password` (string) - Required - Login password
- `--timeout` (integer) - Optional - API timeout in seconds (default: 10)
- `--insecure` (boolean) - Optional - Disable TLS certificate verification (default: false)

#### Command Flags
- `--id` (integer) - Required - The numeric ID of the monitor to update.
- `--field` (key=value pairs) - Optional - Specific fields to update for the monitor. Can be repeated.
- `--data-json` (string) - Optional - A JSON string representing the monitor configuration updates.
- `--data-file` (string) - Optional - Path to a JSON file containing the monitor configuration updates.
- `--json` (boolean) - Optional - Output in JSON format

### Request Example
```bash
# Update retry count
kumacli --url http://localhost:3001 --username admin --password secret monitors update --id 1 --field "maxretries=5" --json
```

### Response
#### Success Response (200)
- `message` (string) - Confirmation message indicating the update was successful.

#### Response Example
```json
{"message": "Updated Successfully."}
```
```

--------------------------------

### Pause a monitor

Source: https://context7.com/vedmaka/kumacli/llms.txt

Temporarily stop monitoring for a specific monitor without deleting it. Useful before maintenance or deployments.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors pause --id 1 --json
```

--------------------------------

### Update a monitor's name and interval

Source: https://context7.com/vedmaka/kumacli/llms.txt

Use this command to rename a monitor and change its polling interval. Ensure the monitor ID is correct.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors update --id 2 \
  --name "DB Primary" \
  --field "interval=120" \
  --json
```

--------------------------------

### maintenance pause / resume

Source: https://context7.com/vedmaka/kumacli/llms.txt

Pause or resume a scheduled maintenance window without removing it. This allows you to temporarily disable or re-enable a maintenance period.

```APIDOC
## maintenance pause / resume

Pause or resume a scheduled maintenance window without removing it.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance pause --id 9 --json
# Output: {"maintenance_id": 9, "message": "Paused Successfully."}

kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance resume --id 9 --json
```
```

--------------------------------

### Delete a monitor

Source: https://context7.com/vedmaka/kumacli/llms.txt

Permanently remove a monitor from the system using its unique ID. This action is irreversible.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors delete --id 3 --json
```

--------------------------------

### Update an Existing Monitor

Source: https://github.com/vedmaka/kumacli/blob/master/README.md

Update a specific monitor by its ID, modifying fields such as max retries.

```bash
uvx kumacli monitors update --id 1 --field "maxretries=5"
```

--------------------------------

### Update maintenance window title and monitor links

Source: https://context7.com/vedmaka/kumacli/llms.txt

Modify an existing maintenance window's title and associate it with different monitors. Both fields and monitor IDs can be updated simultaneously.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance update --id 5 \
  --title "v2.4.1 Deploy" \
  --date-end "2026-06-15 00:30" \
  --monitor-id 1,4 \
  --json
```

--------------------------------

### maintenance update

Source: https://context7.com/vedmaka/kumacli/llms.txt

Update fields and/or monitor links on an existing maintenance window. You must provide at least one field to update or specify monitor IDs to link or unlink.

```APIDOC
## maintenance update

Update fields and/or monitor links on an existing maintenance window. At least one field or `--monitor-id` must be provided.

```bash
# Update title and add more monitors
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance update --id 5 \
  --title "v2.4.1 Deploy" \
  --date-end "2026-06-15 00:30" \
  --monitor-id 1,4 \
  --json
# Output: {"maintenance_id": 5, "updated_fields": ["dateRange", "title"], "monitor_ids": [1, 4]}

# Only update monitor links
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance update --id 5 --monitor-id 2 --json
```
```

--------------------------------

### monitors update

Source: https://context7.com/vedmaka/kumacli/llms.txt

Update an existing monitor by its ID. You can modify various fields of the monitor, such as its name or interval. Use the --field flag to specify which fields to update.

```APIDOC
## monitors update

Update an existing monitor by its ID. You can modify various fields of the monitor, such as its name or interval. Use the --field flag to specify which fields to update.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors update --id 2 \
  --name "DB Primary" \
  --field "interval=120" \
  --json
# Output: {"monitor_id": 1, "message": "Saved.", "updated_fields": ["maxretries"]}
```
```

--------------------------------

### monitors pause / resume

Source: https://context7.com/vedmaka/kumacli/llms.txt

Pause or resume monitoring for a specific monitor without deleting it. This is useful for temporarily disabling alerts during maintenance or deployments.

```APIDOC
## monitors pause / resume

Pause or resume monitoring for a specific monitor without deleting it.

```bash
# Pause before a deployment
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors pause --id 1 --json
# Output: {"monitor_id": 1, "message": "Paused Successfully."}

# Resume after deployment completes
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors resume --id 1 --json
# Output: {"monitor_id": 1, "message": "Resumed Successfully."}

# Pause multiple monitors in a loop
for id in 1 2 3; do
  kumacli --url http://localhost:3001 --username admin --password secret \
    monitors pause --id "$id" --json
done
```
```

--------------------------------

### Update an Existing Maintenance Window

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Modify an existing maintenance window by its ID, updating its title and associated monitor IDs. JSON output is enabled for the update operation.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance update \
  --id 5 \
  --title "Deploy window updated" \
  --monitor-id 3 \
  --json
```

--------------------------------

### monitors delete

Source: https://context7.com/vedmaka/kumacli/llms.txt

Permanently delete a monitor by its ID.

```APIDOC
## monitors delete

Permanently delete a monitor by ID.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  monitors delete --id 3 --json
# Output: {"monitor_id": 3, "message": "Deleted Successfully."}
```
```

--------------------------------

### Pause a maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Temporarily suspend a scheduled maintenance window without deleting it. This is useful for skipping a scheduled event.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance pause --id 9 --json
```

--------------------------------

### maintenance delete

Source: https://context7.com/vedmaka/kumacli/llms.txt

Permanently delete a maintenance window by its ID. This action cannot be undone.

```APIDOC
## maintenance delete

Permanently delete a maintenance window by ID.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance delete --id 5 --json
# Output: {"maintenance_id": 5, "message": "Deleted Successfully."}
```
```

--------------------------------

### Delete a maintenance window

Source: https://context7.com/vedmaka/kumacli/llms.txt

Permanently remove a maintenance window using its ID. This action cannot be undone.

```bash
kumacli --url http://localhost:3001 --username admin --password secret \
  maintenance delete --id 5 --json
```

--------------------------------

### Delete a Maintenance Window

Source: https://github.com/vedmaka/kumacli/blob/master/SKILL.md

Remove a maintenance window identified by its ID. The operation is confirmed with JSON output.

```bash
uv run kumacli --url http://localhost:3001 --username "$KUMA_USERNAME" --password "$KUMA_PASSWORD" maintenance delete \
  --id 5 \
  --json
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.