Doover CLI

Doover CLI Reference

This skill provides a complete reference for the doover app CLI commands used to create, develop, test, and deploy Doover applications.

Overview

The Doover CLI provides commands for the full application lifecycle:

App Creation

doover app create

Create a new application using the interactive wizard.

doover app create --name my-app --description "My application description"

Options

Examples

# Basic creation
doover app create --name temperature-monitor --description "Monitor temperature sensors"

# With git initialization
doover app create --name my-app --description "My app" --git

# Specify container registry
doover app create \
  --name my-app \
  --description "My app" \
  --container-registry "ghcr.io/getdoover"

# With organization ownership
doover app create \
  --name my-app \
  --description "My app" \
  --owner-org-key "org-uuid-here"

Generated Structure

The command creates a complete project:

my-app/
├── src/my_app/
│   ├── __init__.py
│   ├── application.py
│   ├── app_config.py
│   ├── app_ui.py
│   └── app_state.py
├── simulators/
│   ├── sample/
│   │   ├── main.py
│   │   ├── Dockerfile
│   │   └── pyproject.toml
│   ├── docker-compose.yml
│   └── app_config.json
├── tests/
│   ├── __init__.py
│   └── test_imports.py
├── doover_config.json
├── pyproject.toml
├── Dockerfile
└── README.md

Local Development

doover app run

Run the application locally using docker-compose from the simulators directory.

doover app run

Options

Examples

# Run locally (most common)
doover app run

# Run on remote device
doover app run 192.168.1.100

# Run on remote with custom port
doover app run 192.168.1.100 --port 2376

# Pass additional docker-compose arguments
doover app run -- --build
doover app run -- -d  # Run detached

How It Works

1. Looks for simulators/docker-compose.yml
2. Runs docker compose up with the specified services
3. Services typically include:
   • device_agent - Doover device agent
   • Simulator services - Generate test data
   • Application - Your app under development

Stopping

Press Ctrl+C to stop all services, or if running detached:

cd simulators && docker compose down

Build and Publish

doover app build

Build the Docker image for your application.

doover app build

Options

Examples

# Build current directory
doover app build

# Build specific app
doover app build /path/to/my-app

# Build without buildx (single platform)
doover app build --no-buildx

# Pass additional docker build arguments
doover app build -- --no-cache

Build Arguments

Build arguments are read from doover_config.json:

{
  "my_app": {
    "build_args": "--platform linux/amd64,linux/arm64"
  }
}

doover app publish

Publish your application to the Doover platform and container registry.

doover app publish

Options

Examples

# Full publish (build, push, update)
doover app publish

# Update config only (skip container)
doover app publish --skip-container

# Publish to staging
doover app publish --staging

# Don't regenerate config
doover app publish --no-export-config

# Use specific profile
doover app publish --profile production

Publish Process

1. Exports configuration (regenerates doover_config.json)
2. Builds Docker image
3. Pushes image to configured registry
4. Updates application on Doover platform

Testing and Quality

doover app test

Run pytest tests on your application.

doover app test

Options

Additional arguments are passed to pytest.

Examples

# Run all tests
doover app test

# Run with verbose output
doover app test -- -v

# Run specific test file
doover app test -- tests/test_application.py

# Run tests matching pattern
doover app test -- -k "test_config"

# Show print statements
doover app test -- -s

# Run tests in specific app
doover app test /path/to/my-app

Test File Structure

# tests/test_imports.py
def test_import_app():
    from my_app.application import MyApplication
    assert MyApplication

def test_config():
    from my_app.app_config import MyConfig
    config = MyConfig()
    assert isinstance(config.to_dict(), dict)

def test_ui():
    from my_app.app_ui import MyUI
    ui = MyUI()
    components = ui.fetch()
    assert len(components) > 0

def test_state():
    from my_app.app_state import MyState
    state = MyState()
    assert state.state_machine.state == "initial"

doover app lint

Run the ruff linter to check code quality.

doover app lint

Options

Examples

# Check for issues
doover app lint

# Auto-fix issues
doover app lint --fix

# Lint specific app
doover app lint /path/to/my-app

# Lint and fix specific app
doover app lint /path/to/my-app --fix

Common Issues

doover app format

Format code using ruff formatter.

doover app format

Options

Examples

# Check formatting (dry run)
doover app format

# Apply formatting
doover app format --fix

# Format specific app
doover app format /path/to/my-app --fix

Debugging

doover app channels

Open the channel viewer in your browser for debugging published data.

doover app channels

Options

Examples

# Open local channel viewer
doover app channels

# Connect to specific host
doover app channels --host 192.168.1.100

# Use custom port
doover app channels --port 8080

Usage

1. Run your app with doover app run
2. Open channel viewer with doover app channels
3. View real-time channel data in your browser
4. Debug data format and timing issues

Workflow Examples

New App Development

# 1. Create new app
doover app create --name sensor-monitor --description "Monitor sensors"
cd sensor-monitor

# 2. Edit code
# ... modify src/sensor_monitor/*.py

# 3. Run locally
doover app run

# 4. Debug channels (in another terminal)
doover app channels

# 5. Run tests
doover app test

# 6. Check code quality
doover app lint --fix
doover app format --fix

# 7. Publish when ready
doover app publish

Iterative Development

# Run in background
doover app run -- -d

# Make changes to code
# ...

# Rebuild and restart
cd simulators && docker compose up -d --build my_app

# View logs
docker compose logs -f my_app

# Stop when done
docker compose down

CI/CD Pipeline

# Install dependencies
uv sync

# Run linting
doover app lint
if [ $? -ne 0 ]; then exit 1; fi

# Run tests
doover app test -- -v
if [ $? -ne 0 ]; then exit 1; fi

# Build image
doover app build

# Publish to staging
doover app publish --staging

# Publish to production
doover app publish --profile production

Remote Development

# Deploy to remote device for testing
doover app run 192.168.1.100

# View remote logs
ssh device "docker logs -f my_app"

# Publish directly to device
doover app build
docker save my_app | ssh device "docker load"

Configuration Export

Regenerating Config

After modifying app_config.py, regenerate doover_config.json:

# Using the project script
uv run export-config

# Or directly
uv run python -c "from my_app.app_config import export; export()"

Verifying Config

# Check JSON is valid
python -m json.tool doover_config.json > /dev/null

# View generated schema
cat doover_config.json | jq '.my_app.config_schema'

CLI Profiles

Profiles configure which Doover environment to use. The default profile is dv2.

Setting the Default Profile

Set via environment variable (recommended):

# Add to ~/.bashrc or ~/.zshrc
export DOOVER_PROFILE=dv2

Per-Command Profile

Override for a single command:

doover app publish --profile dv2
doover app publish --profile staging
doover app publish --profile production

Available Profiles

Troubleshooting

Build Failures

# Clean Docker cache
docker builder prune

# Rebuild without cache
doover app build -- --no-cache

# Check Dockerfile syntax
docker build --check .

Run Failures

# Check container logs
cd simulators && docker compose logs

# Verify compose file
docker compose config

# Check port conflicts
lsof -i :49100

Test Failures

# Run with verbose output
doover app test -- -v --tb=long

# Run single test for debugging
doover app test -- tests/test_imports.py::test_config -v

Publish Failures

# Verify authentication
doover auth status

# Check registry access
docker login ghcr.io

# Test build locally first
doover app build

Converted and distributed by TomeVault — claim your Tome and manage your conversions.