Devbox

One-command Docker dev environment for any project. Auto-detects 20+ types (Nuxt/Next/Vite/Python/Go/Rust/Java/Ruby/PHP/C#/Swift/Hugo), matches local languag...

Security Scan

The skill is internally consistent: it implements a Docker-based dev environment generator, requires Docker, and the included scripts and instructions match that purpose (they detect project files, probe local runtimes, generate docker-compose, and may update .gitignore).

Purpose & Capability

Name/description (one-command Docker dev environments) aligns with what the skill requests and does. The only hard requirement listed is docker/docker compose, which is appropriate. The scripts also call optional host runtimes (node, python3, go, rustc, java, etc.) to detect versions; these are presented as optional in SKILL.md and are reasonable for version-detection behavior.

Instruction Scope

The SKILL.md instructs running the bundled scripts. The scripts actively read many project files (package.json, pom.xml, requirements.txt, etc.), probe host binaries for version detection, and write a docker-compose.dev.yml into the project folder. They may also append entries to the project's .gitignore. These actions are consistent with the stated purpose but are file-modifying and should be expected by the user; nothing in the instructions attempts to read unrelated system secrets or transmit data externally. One template in references includes cloudflared with a TUNNEL_TOKEN placeholder — that is a template/example and not required for normal operation, but it could be used to create an external tunnel if the user enables it.

Install Mechanism

There is no automated install spec; the skill is instruction-only with bundled scripts. Nothing in the manifest downloads or executes external archives at install time. The scripts are included in the skill bundle and run only when the user or agent invokes them.

Credentials

The skill declares no required environment variables or credentials. It supports an --env-file option for users to supply an environment file (user-provided), and templates include example service credentials (e.g., devbox/devbox, devbox123) for local developer convenience. The presence of a cloudflared service example that references TUNNEL_TOKEN is expected for that example but not required by the skill; it does not cause the skill to request external secrets by default.

Persistence & Privilege

always:false and normal autonomous invocation are set. The scripts will write files into the target project (docker-compose.dev.yml) and may append entries to .gitignore; they do not modify other skills or system-wide agent settings. SKILL.md suggests copying the script to /usr/local/bin for convenience — that requires elevated privileges and is a user action, not automatic. These behaviors are proportional for a developer-tooling skill but worth highlighting because they change project files and optionally install a command to PATH.

Assessment

This skill appears to do what it claims: it inspects your project, probes optional host runtimes, and writes a docker-compose.dev.yml into the project folder (and may append to .gitignore). Before using it: 1) review the bundled scripts (already included) to confirm no unexpected modifications for your repo; 2) back up or git-commit your project before running so you can revert the generated docker-compose or .gitignore changes; 3) avoid blindly copying the script into /usr/local/bin unless you trust the source and understand you need elevated permissions; 4) inspect generated compose files for any services you don't want (templates include example credentials like devbox/devbox and a cloudflared example with a TUNNEL_TOKEN placeholder); and 5) run first in a non-sensitive project or disposable environment if you want to observe behavior. Overall, the skill is coherent with its purpose.

Devbox — One-Command Docker Dev Environment

Create isolated Docker dev environments for any project with a single command.

How It Works

The scripts/devbox.sh script is bundled with this skill. It:

1. Auto-detects your project type (framework, language, package manager)
2. Reads your local language version (Node, Python, Go, Rust, Java, etc.)
3. Generates a docker-compose.dev.yml with the matching Docker image
4. Optionally attaches database services (PostgreSQL, MySQL, Redis, MongoDB, MinIO)

Usage

After installing this skill, run the bundled script directly:

# Find where the skill is installed
SKILL_DIR=$(clawhub list --json 2>/dev/null | python3 -c "import sys,json; print([s['folder'] for s in json.load(sys.stdin) if s.get('slug')=='docker-devbox'][0])" 2>/dev/null || echo "skills/docker-devbox")

# Run devbox
bash "$SKILL_DIR/scripts/devbox.sh" /path/to/project

# Or copy to PATH for convenience
cp "$SKILL_DIR/scripts/devbox.sh" /usr/local/bin/devbox
chmod +x /usr/local/bin/devbox
devbox /path/to/project

Quick Start

# Auto-detect project type
devbox /path/to/project

# Specify port + attach databases
devbox /path/to/project 8000 --with postgres,redis

# Force framework
devbox /path/to/project --framework java-spring

Supported Project Types

Type	Detection	Default Port	Docker Image
Nuxt 3/4	nuxt.config.*	3000	node:{ver}-bookworm
Next.js	next.config.*	3000	node:{ver}-bookworm
Vue + Vite	vite.config.* + vue	5173	node:{ver}-bookworm
React + Vite	vite.config.* + react	5173	node:{ver}-bookworm
Svelte	svelte.config.*	5173	node:{ver}-bookworm
VitePress	docs/.vitepress/	5173	node:{ver}-bookworm
Node.js backend	package.json	3000	node:{ver}-bookworm
Python FastAPI	requirements.txt + fastapi	8000	python:{ver}-slim
Python Django	manage.py	8000	python:{ver}-slim
Python Flask	requirements.txt + flask	5000	python:{ver}-slim
Go	go.mod	8080	golang:{ver}
Rust	Cargo.toml	8080	rust:{ver}
Java (Spring Boot)	pom.xml + spring-boot	8080	eclipse-temurin:{ver}-jdk
Java (Maven)	pom.xml	8080	eclipse-temurin:{ver}-jdk
Java (Gradle)	build.gradle / .kts	8080	eclipse-temurin:{ver}-jdk
Kotlin	*.kt (no build.gradle)	8080	eclipse-temurin:21-jdk
Ruby on Rails	Gemfile + rails	3000	ruby:{ver}-slim
Ruby Sinatra	Gemfile	4567	ruby:{ver}-slim
PHP Laravel	composer.json + laravel	5000	php:{ver}-cli
PHP	composer.json	8000	php:{ver}-cli
C# / .NET	*.csproj / *.sln	5000	dotnet/sdk:{ver}
Swift	Package.swift	8080	swift:{ver}
Hugo	hugo.toml	1313	klakegg/hugo:ext-alpine
Static HTML	*.html	80	nginx:alpine

Attach Database Services

devbox ./app --with postgres,redis

Service	Image	Port
postgres / pg	postgres:16-alpine	5432
mysql	mysql:8-alpine	3306
redis	redis:7-alpine	6379
mongo	mongo:7	27017
minio	minio/minio	9000/9001

CLI Options

devbox <project-path> [port] [options]

Options:
  --framework <type>    Override auto-detection
  --with <services>     Comma-separated services to attach
  --env-file <path>     Environment variable file
  --use-dockerfile      Use project's existing Dockerfile
  -h, --help            Show help

Dependencies

Required:

• docker + docker compose — the only hard requirement

Optional (for version detection):

• node — Node.js version matching
• python3 — Python version matching
• go — Go version matching
• rustc — Rust version matching
• java — Java version matching
• ruby — Ruby version matching
• php — PHP version matching
• dotnet — .NET version matching
• swift — Swift version matching
• pnpm / yarn / bun — Node.js package manager detection

Optional (for port conflict detection):

• lsof — Detects host processes using a port (falls back to Docker-only check if missing)

Only the runtimes installed on your host are used. If a language is not installed, the script falls back to a sensible default version.

Included Files

scripts/devbox.sh          — Main script (auto-detect + generate compose)
scripts/create-dev-env.sh  — Backward-compatible wrapper
references/docker-templates.md — Ready-to-use compose templates

Docker Templates

See references/docker-templates.md for ready-to-use compose templates for each project type.