CLI Reference

nono -s run --allow-cwd -- my-agent
nono --silent why --path ~/.ssh/id_rsa --op read

nono run [OPTIONS] -- <COMMAND> [ARGS...]

nono shell [OPTIONS]

nono wrap [OPTIONS] -- <COMMAND> [ARGS...]

nono why --path <PATH> --op <OP> [OPTIONS]
nono why --host <HOST> [--port <PORT>] [OPTIONS]
nono why --self --path <PATH> --op <OP> [OPTIONS]  # Inside sandbox

nono learn [OPTIONS] -- <COMMAND> [ARGS...]

nono setup [OPTIONS]

nono trust <SUBCOMMAND>

nono learn --profile opencode -- opencode

nono learn --toml -- my-app > paths.toml

nono learn --timeout 30 -- my-long-running-app

nono learn --all -- my-app

nono learn -vv -- my-app

nono run --allow ./project -- command
nono run -a ./src -a ./tests -- command

nono run --read ./config -- command
nono run -r /etc/myapp -- command

nono run --write ./output -- command
nono run -w ./logs -- command

nono run --allow-file ./database.sqlite -- command

nono run --read-file ./config.toml -- command
nono run --read-file ~/.gitconfig -- command

nono run --write-file ./output.log -- command

# Block network for a build process that should be offline
nono run --allow-cwd --net-block -- cargo build

# Keep the claude-code profile, but bypass its proxy filtering for one run
nono run --profile claude-code --net-allow -- claude

# Use the claude-code network profile
nono run --allow-cwd --network-profile claude-code -- claude

# Use minimal profile (LLM APIs only)
nono run --allow-cwd --network-profile minimal -- my-agent

# Allow specific hosts
nono run --allow-cwd --proxy-allow api.openai.com --proxy-allow api.anthropic.com -- my-agent

# Combine with a network profile for additional hosts
nono run --allow-cwd --network-profile minimal --proxy-allow custom-api.example.com -- my-agent

# Inject OpenAI credentials (loads from keyring account "openai_api_key")
nono run --allow-cwd --network-profile claude-code --proxy-credential openai -- my-agent

# Multiple credentials
nono run --allow-cwd --network-profile claude-code \
  --proxy-credential openai --proxy-credential anthropic -- my-agent

{
  "network": {
    "custom_credentials": {
      "my-api": {
        "upstream": "https://api.example.com",
        "credential_key": "my_api_key"
      }
    }
  }
}

nono run --allow-cwd --network-profile enterprise --external-proxy squid.corp:3128 -- my-agent

# Use a fixed proxy port for applications that need base URL configuration
nono run --profile openclaw --proxy-port 19999 --allow-bind 18789 -- openclaw gateway

# The credential proxy will always be at http://127.0.0.1:19999
# Configure the application to use this base URL for API calls

# Allow OpenClaw gateway to listen on its default port
nono run --profile openclaw --allow-bind 18789 \
  --proxy-credential openai -- openclaw gateway

# Allow a development server
nono run --allow-cwd --network-profile developer --allow-bind 3000 -- npm run dev

# MCP server in one sandbox, client in another — both can use port 3000
nono run --net-block --allow-port 3000 --allow ./mcp-server -- node server.js
nono run --net-block --allow-port 3000 --allow ./client -- claude

# Multiple IPC ports
nono run --net-block --allow-port 3000 --allow-port 5000 --allow-cwd -- my-agent

# Combine with proxy mode — outbound filtered + localhost IPC on port 4000
nono run --network-profile claude-code --allow-port 4000 --allow-cwd -- claude

nono shell --allow-cwd --shell /bin/zsh

# Allow rm (blocked by default)
nono run --allow-cwd --allow-command rm -- rm ./temp-file.txt

# Allow multiple commands
nono run --allow-cwd --allow-command rm --allow-command mv -- my-script.sh

{
  "meta": { "name": "my-profile" },
  "filesystem": { "allow": ["/tmp"] },
  "security": { "allowed_commands": ["rm", "chmod"] }
}

nono run --profile my-profile -- rm /tmp/old-file.txt

# Block a custom tool in addition to defaults
nono run --allow-cwd --block-command my-dangerous-tool -- my-script.sh

# Allow an AWS agent to access credentials
nono run --override-deny ~/.aws --allow ~/.aws -- my-aws-agent

# Allow read-only access to GCP config
nono run --override-deny ~/.config/gcloud --read ~/.config/gcloud -- gcloud-agent

# Multiple overrides
nono run \
  --override-deny ~/.aws \
  --override-deny ~/.config/gcloud \
  --allow ~/.aws \
  --read ~/.config/gcloud \
  -- multi-cloud-agent

# Load specific credentials by account name
nono run --allow-cwd --env-credential openai_api_key,anthropic_api_key -- my-agent

# Load from 1Password (op:// URI with =VAR_NAME suffix)
nono run --allow-cwd --env-credential 'op://Development/OpenAI/credential=OPENAI_API_KEY' -- my-agent

# Use with profile (loads credentials defined in profile's [env_credentials] section)
nono run --profile claude-code --env-credential -- claude

nono run --profile claude-code -- claude
nono run -p openclaw -- openclaw gateway

nono run --profile claude-code --workdir ./my-project -- claude

# Non-interactive mode (e.g., CI/CD)
nono run --profile claude-code --allow-cwd -- claude

# Silent mode requires --allow-cwd (cannot prompt)
nono -s run --profile claude-code --allow-cwd -- claude

nono run --rollback --profile claude-code -- claude
nono run --rollback --allow-cwd -- my-agent

nono run --rollback --no-rollback-prompt --allow-cwd -- my-agent

nono run --no-rollback --allow-cwd -- npm test

nono run --no-audit --allow-cwd -- my-command

# Exclude a custom directory from rollback
nono run --rollback --rollback-exclude vendor -- go test ./...

# Exclude multiple directories
nono run --rollback --rollback-exclude vendor --rollback-exclude .terraform -- terraform plan

# Exclude log files from rollback (glob pattern)
nono run --rollback --rollback-exclude "*.log" -- my-agent

# Include target/ in rollback (normally auto-excluded)
nono run --rollback --rollback-include target -- cargo build

# Include multiple directories
nono run --rollback --rollback-include target --rollback-include dist -- make build

# Full rollback coverage (may be slow)
nono run --rollback --rollback-all -- cargo test

nono run --no-diagnostics --allow-cwd -- my-command

nono run --capability-elevation --allow-cwd -- my-agent

nono run --allow-cwd --read /etc --dry-run -- my-agent

Capabilities that would be granted:
  [rw] /Users/luke/project
  [r-] /etc
  [net] allowed

Would execute: my-agent

nono run -vvv --allow-cwd -- command

nono run --trust-override --allow-cwd -- my-agent

nono run --config ./nono.toml -- command

nono why --path ~/.ssh/id_rsa --op read
nono why --path ./my-project --op write

nono why --path ./src --op read
nono why --path ./output --op write
nono why --path ./data --op readwrite

nono why --host api.openai.com --port 443

nono why --host example.com --port 8080

nono why --json --path ~/.ssh --op read
# {"status":"denied","reason":"sensitive_path","category":"SSH keys and config",...}

# Inside a sandbox:
nono why --self --path /tmp --op write --json

# Check if ./src would be writable with --allow .
nono why --path ./src --op write --allow .

# Check against a profile
nono why --path ~/.config --op read --profile claude-code

nono trust sign <FILES...>                 # Sign specific files
nono trust sign --all                      # Sign all instruction files in CWD
nono trust sign SKILLS.md --key my-key     # Use a specific key

nono trust sign-policy                     # Sign trust-policy.json in CWD
nono trust sign-policy path/to/policy.json # Sign specific file
nono trust sign-policy --key my-key        # Use a specific key

nono trust verify <FILES...>               # Verify specific files
nono trust verify --all                    # Verify all instruction files in CWD
nono trust verify --policy path/to/policy  # Use specific trust policy

nono trust list                            # Human-readable output
nono trust list --json                     # JSON output

nono trust keygen                          # Default key ID ("default")
nono trust keygen --id my-signing-key      # Named key

nono trust export-key                      # Export default key (base64 DER)
nono trust export-key --id my-key          # Export named key
nono trust export-key --pem                # Output as PEM format

nono setup --check-only

nono setup --profiles

nono setup --shell-integration

nono setup -v --profiles

# These are equivalent if ./project resolves to /home/user/project
nono run --allow ./project -- command
nono run --allow /home/user/project -- command

nono run \
  --allow ./project \
  --read ~/.config/myapp \
  --write ./logs \
  --read-file ~/.gitconfig \
  -vv \
  -- my-agent --arg1 --arg2

# CI/CD example: configure nono via environment
export NONO_PROFILE=developer
export NONO_ALLOW=/workspace
export NONO_NET_BLOCK=true
nono run -- cargo build