CLI reference
Every coma command, its flags and examples, generated from the CLI's own help.
Generated from coma --help for coma v0.1.0-rc.4-3-g07087e6. Global flags are listed once, under coma; every command accepts them. Every command also takes --json (see JSON output).
coma
COMA points your Docker and Podman workflows, and your AI coding agents,
at remote machines while bind mounts, localhost ports and interactive commands
keep working.
Every command supports --json for scripts and AI agents. Human output goes to
stdout; warnings, progress and errors go to stderr.
Docs and issues: https://github.com/okolilemuel/coma
USAGE
coma [command] [--flags]
EXAMPLES
# Register a machine you own and make it the default target
coma machine add dev ssh://you@203.0.113.10
coma use dev
# Run the docker CLI on that machine
coma docker ps
# Check that COMA is installed correctly
coma doctor
# Machine-readable output for scripts and AI agents
coma machine list --json
COMMANDS
completion [command] Generate the autocompletion script for the specified shell
connect [machine] [--flags] Point your Docker CLI and tools at a machine's engine
context [command] Manage contexts: named default targets for commands
daemon [command] Inspect or stop comad, COMA's background process
disconnect Switch the Docker CLI back to the context it used before `coma connect`
docker <args...> [--flags] Run the docker CLI on the target machine
docker-context [command] Manage Docker contexts that reach a machine's engine
doctor Check the local COMA installation
endpoint [command] Inspect and stop the local Docker API endpoints COMA serves
engine [command] Show the Docker and Podman engines on your machines
help [command] Help about any command
machine [command] [--flags] Register and inspect the machines your containers run on
podman <args...> [--flags] Run the podman CLI on the target machine
port [command] Show container ports COMA makes reachable on localhost
sync [command] Keep a local directory on a machine so bind mounts work
use <machine> Make a machine the default target of the current context
version Show build information
workspace [command] Run a project on a machine from its coma.yaml
FLAGS
--config Use this config file instead of the default
--context Use this COMA context for this invocation only
--debug Print debug logs to stderr
-h --help Help for coma
--json Write machine-readable JSON to stdout
--log-format Log format on stderr: text or json
--no-color Disable colors (also NO_COLOR, COMA_NO_COLOR)
--no-input Never prompt; fail with the flag to use instead
-q --quiet Only print results and errors
--timeout Bound operations, e.g. 2m (default: config, 30s)
--trace Print trace logs, including timings, to stderr
--verbose Print more detail about what is happening
--version Show the version
--yes Confirm eligible actions without promptingcoma completion
Generate the autocompletion script for coma for the specified shell.
See each sub-command's help for details on how to use the generated script.
USAGE
coma completion [command] [--flags]
COMMANDS
bash [--flags] Generate the autocompletion script for bash
fish [--flags] Generate the autocompletion script for fish
powershell [--flags] Generate the autocompletion script for powershell
zsh [--flags] Generate the autocompletion script for zshcoma completion bash
Generate the autocompletion script for the bash shell.
This script depends on the 'bash-completion' package.
If it is not installed already, you can install it via your OS's package manager.
To load completions in your current shell session:
source <(coma completion bash)
To load completions for every new session, execute once:
#### Linux:
coma completion bash > /etc/bash_completion.d/coma
#### macOS:
coma completion bash > $(brew --prefix)/etc/bash_completion.d/coma
You will need to start a new shell for this setup to take effect.
USAGE
coma completion bash [--flags]
FLAGS
--no-descriptions Disable completion descriptionscoma completion fish
Generate the autocompletion script for the fish shell.
To load completions in your current shell session:
coma completion fish | source
To load completions for every new session, execute once:
coma completion fish > ~/.config/fish/completions/coma.fish
You will need to start a new shell for this setup to take effect.
USAGE
coma completion fish [--flags]
FLAGS
--no-descriptions Disable completion descriptionscoma completion powershell
Generate the autocompletion script for powershell.
To load completions in your current shell session:
coma completion powershell | Out-String | Invoke-Expression
To load completions for every new session, add the output of the above command
to your powershell profile.
USAGE
coma completion powershell [--flags]
FLAGS
--no-descriptions Disable completion descriptionscoma completion zsh
Generate the autocompletion script for the zsh shell.
If shell completion is not already enabled in your environment you will need
to enable it. You can execute the following once:
echo "autoload -U compinit; compinit" >> ~/.zshrc
To load completions in your current shell session:
source <(coma completion zsh)
To load completions for every new session, execute once:
#### Linux:
coma completion zsh > "${fpath[1]}/_coma"
#### macOS:
coma completion zsh > $(brew --prefix)/share/zsh/site-functions/_coma
You will need to start a new shell for this setup to take effect.
USAGE
coma completion zsh [--flags]
FLAGS
--no-descriptions Disable completion descriptionscoma connect
Point your Docker CLI, Compose and Docker-aware tools at a machine's engine.
COMA starts its background daemon (comad) if needed, opens a local Docker
API socket for the machine, installs a Docker context called "coma" and
makes it the Docker CLI's current context. Every new shell, including ones
started by AI coding agents, then uses the machine. Nothing is exposed on
the network: the socket is private to you and traffic goes over SSH.
With a Podman engine, COMA also adds a podman connection called "coma"
and makes it the default, so the podman CLI (and a docker alias for it)
uses the machine too. --no-switch leaves both defaults alone.
`coma disconnect` switches the Docker CLI and podman back.
USAGE
coma connect [machine] [--flags]
EXAMPLES
coma connect # the current context's machine
coma connect dev --engine podman
coma connect dev --no-switch && docker --context coma ps
FLAGS
--engine Engine to use when the machine has both: docker or podman
--no-switch Install the coma context but keep the Docker CLI's and podman's defaults
--replace Take over an existing Docker context named coma that COMA did not createcoma context
Manage contexts: named default targets for commands
USAGE
coma context [command] [--flags]
EXAMPLES
coma context create work
coma context use work
coma context list
COMMANDS
create <name> [--flags] Create a context
current Show the current context and where it was chosen
inspect <name> Show a context
list List contexts
remove <name> Remove a context (machines it points at are not affected)
rename <name> <new-name> Rename a context
use <name> Make a context currentcoma context create
Create a context
USAGE
coma context create <name> [--flags]
FLAGS
--description Describe what the context is for
--use Make it the current contextcoma context current
Show the current context and where it was chosen
USAGE
coma context current [--flags]coma context inspect
Show a context
USAGE
coma context inspect <name> [--flags]coma context list
List contexts
USAGE
coma context list [--flags]coma context remove
Remove a context (machines it points at are not affected)
USAGE
coma context remove <name> [--flags]coma context rename
Rename a context
USAGE
coma context rename <name> <new-name> [--flags]coma context use
Make a context current
USAGE
coma context use <name> [--flags]coma daemon
comad is COMA's per-user background process. It serves endpoint sockets
and keeps one SSH connection per machine alive. `coma connect` starts it when
needed; it exits on its own after 10 minutes with nothing to serve.
USAGE
coma daemon [command] [--flags]
COMMANDS
logs [--flags] Print the end of comad's log
run [--flags] Run comad in the foreground (COMA normally starts it for you)
status Show whether comad is running, its version and endpoints
stop Stop comad; Docker commands through COMA fail until the next coma connectcoma daemon logs
Print the end of comad's log
USAGE
coma daemon logs [--flags]
FLAGS
--lines How many lines to print (50)coma daemon run
Run comad in the foreground (COMA normally starts it for you)
USAGE
coma daemon run [--flags]
FLAGS
--idle-exit Exit after this long with no endpoints (10m0s)coma daemon status
Show whether comad is running, its version and endpoints
USAGE
coma daemon status [--flags]coma daemon stop
Stop comad; Docker commands through COMA fail until the next coma connect
USAGE
coma daemon stop [--flags]coma disconnect
Switch the Docker CLI back to the context it used before `coma connect`.
The endpoint keeps serving running commands (such as docker logs -f) and
stops once nothing has used it for two minutes.
USAGE
coma disconnect [--flags]coma docker
Run the docker CLI on the target machine, exactly as if you had
logged in and typed it there. Output, exit codes and interactive terminals
are docker's own; COMA only picks the machine (--machine, or the
current context) and connects with a verified host key.
Put COMA's flags first. Everything after the first docker argument, or
after --, goes to docker unchanged.
USAGE
coma docker <args...> [--flags]
EXAMPLES
coma docker ps -a
coma docker --machine dev -- system df
coma docker run --rm -it alpine sh
FLAGS
--machine Machine to run on (default: the current context's machine)coma docker-context
Manage Docker contexts that reach a machine's engine.
`coma connect` switches the Docker CLI to the context `coma`, which follows
whichever machine you connected to last. `coma docker-context install` adds a
context fixed to one machine and engine instead, without switching to it,
so you can use several at once:
docker --context coma-dev-docker ps
COMA only changes contexts it created, and says so when one was edited
outside COMA.
USAGE
coma docker-context [command] [--flags]
COMMANDS
inspect <name> Show a COMA Docker context
install [name] [--flags] Add a Docker context for a machine's engine
list List the Docker contexts COMA manages
remove <name> Remove a Docker context COMA created
verify <name> Check a COMA Docker context reaches a working enginecoma docker-context inspect
Show a COMA Docker context
USAGE
coma docker-context inspect <name> [--flags]coma docker-context install
Add a Docker context for a machine's engine, named coma-<machine>-<engine>
unless you give a name. The endpoint starts if needed; the Docker CLI's
current context is not changed. Running install again repairs the context.
USAGE
coma docker-context install [name] [--flags]
EXAMPLES
coma docker-context install --machine dev --engine docker
coma docker-context install dev --machine dev
docker --context coma-dev-docker compose up
FLAGS
--engine Engine: docker or podman
--machine Machine (default: the context's)
--replace Take over a context with this name that COMA did not createcoma docker-context list
List the Docker contexts COMA manages
USAGE
coma docker-context list [--flags]coma docker-context remove
Remove a Docker context COMA created. If it is the current context, the
Docker CLI switches back to the context it replaced, or to default. The
endpoint keeps running; `coma endpoint stop` stops it.
USAGE
coma docker-context remove <name> [--flags]coma docker-context verify
Check a COMA Docker context: it exists, still points where COMA wrote it,
its endpoint exists and runs, and the engine answers through it. A context
changed outside COMA fails with docker_context_drifted.
USAGE
coma docker-context verify <name> [--flags]coma doctor
Check the local COMA installation: build, platform, file locations,
config, state database and current context. Then check the laptop's own
tools for traps that send commands somewhere other than the machine:
containers created on a local engine while connected, Docker credential
helpers that are not installed, Compose v1 on PATH, and a podman CLI that
does not follow the connected engine.
Every check reports PASS, WARN or FAIL with a remediation hint. The report is
always written to stdout (with --json, as a DoctorReport envelope). The exit
code is 10 (doctor_failed) when any check fails, so scripts and AI agents can
act on it.
USAGE
coma doctor [--flags]coma endpoint
Inspect and stop the local Docker API endpoints COMA serves.
An endpoint is a private Unix socket on this computer that speaks the
Docker API and forwards it over SSH to one machine's engine. `coma connect`
creates and starts them.
USAGE
coma endpoint [command] [--flags]
COMMANDS
doctor <name|id> [--flags] Check an endpoint end to end: comad, the engine, the Docker context
env [--flags] Print DOCKER_HOST for tools that ignore Docker contexts
list List endpoints and their live state
remove <name|id> Stop an endpoint and forget it (the machine is not changed)
start [--flags] Start an endpoint without switching the Docker CLI or podman
status <name|id> Show one endpoint's live state
stop <name|id> Stop an endpoint now (Docker commands through it fail until reconnected)coma endpoint doctor
Check an endpoint end to end: comad, the engine, the Docker context.
With --explain-last, show what COMA changed in the most recent request it
intercepted: port publications moved to the machine's loopback, bind
sources mapped to the synced copy, a start held for port mirrors, or why
a request was refused. Request bodies are never shown or logged.
USAGE
coma endpoint doctor <name|id> [--flags]
EXAMPLES
coma endpoint doctor dev-docker
coma endpoint doctor dev-docker --explain-last
FLAGS
--explain-last Show what COMA changed in the last request it interceptedcoma endpoint env
Print shell code that points DOCKER_HOST at COMA's stable socket, which
`coma connect` re-points to the current machine. Use it for SDKs and tools that
ignore Docker contexts:
eval "$(coma endpoint env)"
With --podman it sets CONTAINER_HOST instead, so the podman CLI (and a
docker alias for it) uses the machine's Podman engine; connect with
`coma connect --engine podman` first.
USAGE
coma endpoint env [--flags]
FLAGS
--podman Set CONTAINER_HOST for the podman CLI instead of DOCKER_HOST
--shell Shell syntax: bash, zsh, fish, powershell (default: from $SHELL)coma endpoint list
List endpoints and their live state
USAGE
coma endpoint list [--flags]coma endpoint remove
Stop an endpoint and forget it (the machine is not changed)
USAGE
coma endpoint remove <name|id> [--flags]coma endpoint start
Start the endpoint for a machine and engine, and print its socket.
Unlike `coma connect`, the Docker context and podman's default are not
touched: use the socket with DOCKER_HOST, or `coma endpoint env`.
USAGE
coma endpoint start [--flags]
EXAMPLES
coma endpoint start --machine dev --engine docker
FLAGS
--engine Engine: docker or podman
--machine Machine (default: the context's)coma endpoint status
Show one endpoint's live state
USAGE
coma endpoint status <name|id> [--flags]coma endpoint stop
Stop an endpoint now (Docker commands through it fail until reconnected)
USAGE
coma endpoint stop <name|id> [--flags]coma engine
Show the Docker and Podman engines COMA found on your machines.
Engines are detected by `coma machine add` and refreshed by
`coma machine discover`; these commands read that record and do
not contact the machine.
USAGE
coma engine [command] [--flags]
EXAMPLES
coma engine list
coma engine inspect --machine dev
coma engine use podman
COMMANDS
inspect [docker|podman] [--flags] Show an engine's version, socket, Compose, health and capabilities
list [--flags] List detected engines (from local state; no network)
use <docker|podman|auto> Set the engine the current context preferscoma engine inspect
Show an engine's version, socket, Compose, health and capabilities.
Without an engine name, COMA picks one as other commands would: the
context's preference, or the machine's only working engine.
USAGE
coma engine inspect [docker|podman] [--flags]
FLAGS
--machine Machine to inspect (default: the current context's machine)coma engine list
List detected engines (from local state; no network)
USAGE
coma engine list [--flags]
FLAGS
--machine Only this machine's enginescoma engine use
Set the engine the current context prefers when its machine has both
Docker and Podman. "auto" clears the preference, so COMA uses the machine's
only working engine and asks you to choose when there are two.
USAGE
coma engine use <docker|podman|auto> [--flags]
EXAMPLES
coma engine use podman
coma engine use auto --context workcoma machine
Register and inspect the machines your containers run on
USAGE
coma machine [command] [--flags]
EXAMPLES
# Register a VM you own; COMA verifies its host key and inventories it
coma machine add dev ssh://lemuel@203.0.113.10
# Make it the default target
coma use dev
COMMANDS
add <name> <ssh://user@host> [:port] [--flags] Register an SSH machine (verifies the host key; changes nothing on it)
bootstrap <name> [--flags] Prepare a machine for COMA, installing a container engine if asked
discover <name> [--flags] Refresh a machine's inventory and health (read-only on the machine)
inspect <name> Show what COMA knows about a machine (cached; see `machine discover`)
list List registered machines (from local state; no network)
remove <name> [--flags] Forget a machine (the server itself is not changed)
use <machine> Make a machine the default target of the current contextcoma machine add
Register a Linux machine you already own or rent.
COMA connects over SSH, verifies the host key, and records an inventory (OS,
CPU, memory, disk, engines). It never changes anything on the machine.
The first time COMA sees a host key it asks you to confirm the fingerprint.
Without a terminal (scripts, AI agents, --no-input) pass the fingerprint
with --host-key; the error message tells you what it is.
USAGE
coma machine add <name> <ssh://user@host> [:port] [--flags]
EXAMPLES
coma machine add dev ssh://lemuel@203.0.113.10
coma machine add dev lemuel@bigbox:2222 --identity ~/.ssh/bigbox
coma machine add dev root@203.0.113.10 --host-key SHA256:AbC...xyz --no-input
FLAGS
--description Describe the machine
--discover Connect, verify and inventory now (false: only record it) (true)
--host-key Expected host key fingerprint (SHA256:...), for non-interactive first use
--identity Private key file (repeatable; default: ssh-agent, then ~/.ssh/id_*)
--label Label as key=value (repeatable)coma machine bootstrap
Prepare a machine for COMA, installing a container engine if asked.
Bootstrap creates COMA's directories under ~/.coma and, with --engine,
installs Docker or Podman from the distribution's own packages (apt on
Debian and Ubuntu) and sets it up for your SSH user.
COMA shows the plan, with every command it would run, and asks before it
changes anything. Each step is checked first and verified after, so running
bootstrap again changes nothing on a ready machine and resumes one that was
interrupted. Steps marked sudo need passwordless sudo on the machine.
USAGE
coma machine bootstrap <name> [--flags]
EXAMPLES
# See what would change, without changing anything
coma machine bootstrap dev --engine docker --plan
# Install Docker (asks first; --yes for scripts and AI agents)
coma machine bootstrap dev --engine docker
# Rootless Podman instead
coma machine bootstrap dev --engine podman --yes
FLAGS
--engine Install this engine: docker or podman
--harden-publish Also make Docker publish ports on 127.0.0.1 by default (restarts Docker)
--host-key Expected host key fingerprint, if COMA does not know it
--plan Show the plan and change nothingcoma machine discover
Refresh a machine's inventory and health (read-only on the machine)
USAGE
coma machine discover <name> [--flags]
FLAGS
--host-key Expected host key fingerprint, if COMA does not know itcoma machine inspect
Show what COMA knows about a machine (cached; see `machine discover`)
USAGE
coma machine inspect <name> [--flags]coma machine list
List registered machines (from local state; no network)
USAGE
coma machine list [--flags]coma machine remove
Forget a machine (the server itself is not changed)
USAGE
coma machine remove <name> [--flags]
FLAGS
--detach Also clear the machine from contexts that use itcoma machine use
Make a machine the default target of the current context.
If no context exists yet, COMA creates one called "default" and makes it
current. This does not change where the docker CLI points.
USAGE
coma machine use <machine> [--flags]coma podman
Run the podman CLI on the target machine, exactly as if you had
logged in and typed it there. Output, exit codes and interactive terminals
are podman's own; COMA only picks the machine (--machine, or the
current context) and connects with a verified host key.
Put COMA's flags first. Everything after the first podman argument, or
after --, goes to podman unchanged.
USAGE
coma podman <args...> [--flags]
EXAMPLES
coma podman ps -a
coma podman --machine dev -- system df
coma podman run --rm -it alpine sh
FLAGS
--machine Machine to run on (default: the current context's machine)coma port
Show container ports COMA makes reachable on localhost.
While you are connected, every TCP port a container publishes on the
machine is also open on this computer at the same number: a container
published on 3000 is at localhost:3000. On the machine itself COMA
publishes ports on 127.0.0.1 only, so nothing is exposed to the network.
A workspace's coma.yaml can declare ports (spec.ports) to use another
local number, `local: auto`, or no local port at all; a declared port
replaces the mirror of the same remote port while the workspace is up.
USAGE
coma port [command] [--flags]
COMMANDS
list List mirrored and declared ports and their statecoma port list
List mirrored and declared ports and their state
USAGE
coma port list [--flags]coma sync
Keep a local directory on a machine so bind mounts work.
COMA copies the directory to the machine and keeps it current as you edit
(changes appear within about a second). Containers created through
`coma connect` that bind-mount paths inside it get the machine's copy,
so `./src:/app/src` in a Compose file just works.
Files in .gitignore and .comaignore (and .git/) are not copied. COMA never
deletes files on the machine: deleting a file locally leaves the remote
copy. Bind mounts outside a synced directory are refused.
USAGE
coma sync [command] [--flags]
COMMANDS
explain <path> [--flags] Say whether a path is synced and which ignore rule decided
resolve <path> --keep local|machine [--flags] Settle a sync conflict by keeping your copy or the machine's
status Show synced directories and their state
stop [--flags] Stop syncing a directory (its copy stays on the machine)
watch [--flags] Start syncing a directory to the current machinecoma sync explain
Say whether a path is synced and which ignore rule decided
USAGE
coma sync explain <path> [--flags]
FLAGS
--path The synced directory (.)coma sync resolve
Settle a sync conflict on one file. One-way-safe sync never overwrites a
file that changed on the machine, so a file changed in both places is a
conflict and the machine's copy stays. --keep local copies your version to
the machine; --keep machine copies the machine's version here. Either way
the conflict clears once sync has caught up.
USAGE
coma sync resolve <path> --keep local|machine [--flags]
EXAMPLES
coma sync resolve src/app.py --keep local
coma sync resolve config/generated.json --keep machine
FLAGS
--keep Which copy wins: local or machinecoma sync status
Show synced directories and their state
USAGE
coma sync status [--flags]coma sync stop
Stop syncing a directory (its copy stays on the machine)
USAGE
coma sync stop [--flags]
FLAGS
--path Directory to stop syncing (.)coma sync watch
Start syncing a directory to the current machine
USAGE
coma sync watch [--flags]
EXAMPLES
coma sync watch # the current directory
coma sync watch --path ~/code/app --machine dev
FLAGS
--machine Machine to sync to (default: the current context's machine)
--path Directory to sync (.)coma use
Make a machine the default target of the current context.
If no context exists yet, COMA creates one called "default" and makes it
current. This does not change where the docker CLI points.
USAGE
coma use <machine> [--flags]coma version
Show build information
USAGE
coma version [--flags]coma workspace
Run a project on a machine from its coma.yaml.
A workspace is a directory with a coma.yaml that says which machine and
engine it uses. `coma workspace up` connects the Docker CLI (and podman) to
that machine and keeps the source synced there, so a following
`docker compose up` in any terminal runs remotely with bind mounts and
localhost ports working.
USAGE
coma workspace [command] [--flags]
COMMANDS
delete [workspace] [--flags] Forget a workspace, and with --remote remove its copy on the machine
down [--flags] Stop syncing the workspace's source
init [--flags] Write a coma.yaml for the current directory
list List registered workspaces
plan [--flags] Show what workspace up would do, without changing anything
status [workspace] [--flags] Show a workspace's health
up [--flags] Connect to the workspace's machine and sync its source
validate [--flags] Check coma.yaml and show where any problem iscoma workspace delete
Forget a workspace: its sync stops and COMA forgets it. With --remote, the
copy of the source on the machine is removed too.
The source directory, containers, images, volumes and the endpoint are never
touched. COMA shows what it will do and asks first (--yes for scripts).
USAGE
coma workspace delete [workspace] [--flags]
EXAMPLES
coma workspace delete # the workspace of ./coma.yaml
coma workspace delete gastanker --remote --yes
FLAGS
--file Manifest to use (default: coma.yaml here or above)
--remote Also remove the source's copy on the machinecoma workspace down
Stop syncing the workspace's source. Containers, the remote copy and the
endpoint are left alone: stop containers with `docker compose down`, and
switch the CLIs back with `coma disconnect`.
USAGE
coma workspace down [--flags]
FLAGS
--file Manifest to use (default: coma.yaml here or above)coma workspace init
Write a minimal coma.yaml for the current directory, naming the Compose
file it finds. The machine is written only with --machine: machine names
are per user, and coma.yaml is meant to be committed. Without one,
`workspace up` uses the current context's machine.
USAGE
coma workspace init [--flags]
FLAGS
--engine Engine to write: docker or podman
--force Replace an existing coma.yaml
--machine Machine to write into spec.target
--name Workspace name (default: the directory's name)
--path Project directory to write coma.yaml into (.)coma workspace list
List registered workspaces
USAGE
coma workspace list [--flags]coma workspace plan
Show what workspace up would do, without changing anything
USAGE
coma workspace plan [--flags]
FLAGS
--engine Engine to use instead of spec.runtime.engine: docker or podman
--file Manifest to use (default: coma.yaml here or above)
--machine Machine to use instead of spec.target.machine
--no-connect Plan without switching the Docker context and podman default
--no-sync Plan without syncing the sourcecoma workspace status
Show a workspace's health
USAGE
coma workspace status [workspace] [--flags]
FLAGS
--file Manifest to use (default: coma.yaml here or above)coma workspace up
Connect to the workspace's machine and sync its source.
Registers the workspace, starts its endpoint, points the Docker context
`coma` (and, for Podman, podman's default connection) at it, and syncs the
source so bind mounts work. Containers are not started: run
`docker compose up` next, in any terminal. Running up again is safe.
USAGE
coma workspace up [--flags]
EXAMPLES
coma workspace up
coma workspace up --machine dev --engine podman
FLAGS
--engine Engine to use instead of spec.runtime.engine: docker or podman
--file Manifest to use (default: coma.yaml here or above)
--machine Machine to use instead of spec.target.machine
--no-connect Keep the Docker CLI's and podman's defaults; use docker --context coma
--no-sync Do not sync the sourcecoma workspace validate
Check coma.yaml and show where any problem is
USAGE
coma workspace validate [--flags]
FLAGS
--file Manifest to use (default: coma.yaml here or above)