ops run local
- Repo stars 0
- Author repo skills-registry
- Domain
- DevOps
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 88 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @tomevault-io · no license declared
- Token usage
- Lean
- Setup complexity
- Manual integration
- External API key
- Not required
- Operating systems
- Docker
- Runtime requirements
- Docker
- Detected file/system behavior
-
- Read-only
- Write / modify
- Shell exec
- Network behavior
- External requests
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
# Ops: Run Local
Manage the local Docker Compose development environment.
**Argument**: `$ARGUMENTS` — `start`, `stop`, `restart`, `status`, `start-app`, `start-services` (default: `start`)
## Prerequisites (run before any operation)
1. Verify Docker is running:
```bash
docker info > /dev/null 2>&1 && echo "Docker OK" || echo "ERROR: Docker is not running — start Docker Desktop"
```
2. Check port availability:
```bash
lsof -i :3000 2>/dev/null | grep LISTEN
lsof -i :5432 2>/dev/null | grep LISTEN
```
3. Verify Ruby and Bundler are available:
```bash
ruby --version && bundle --version
```
## Discovery
Read the project's `docker-compose.yml` (or `compose.yaml`) to identify available services. Common services include:
- `web` or `app` — the Rails application
- `postgres` or `db` — PostgreSQL database
- `worker` — Solid Queue background worker
- `css` — Tailwind CSS watch process
Read `Procfile.dev` if it exists — it defines the local development process manager configuration (typically run via `bin/dev`).
Read `config/database.yml` to understand which databases need to exist locally.
## Operations
### start (full stack)
Start all Docker Compose services and the Rails application.
1. **Start infrastructure services** (PostgreSQL, etc.):
```bash
docker compose up -d postgres
```
2. **Wait for PostgreSQL** (up to 30 seconds):
```bash
for i in $(seq 1 30); do
docker compose exec -T postgres pg_isready -U postgres > /dev/null 2>&1 && echo "PostgreSQL ready" && break
sleep 1
done
```
3. **Create and migrate databases** (if needed):
```bash
bin/rails db:prepare
```
4. **Start the full stack** via `bin/dev` (Procfile.dev) or Docker Compose:
```bash
# Option A: Procfile.dev (preferred — starts web, worker, CSS watcher)
bin/dev
```
Run this in the background using the Bash tool with `run_in_background: true`.
```bash
# Option B: Docker Compose (if all services are containerized)
docker compose up -d
```
5. **Wait for Rails** (up to 60 seconds):
```bash
for i in $(seq 1 60); do
curl -sf http://localhost:3000/up > /dev/null 2>&1 && echo "Rails ready" && break
sleep 1
done
```
6. Report status table.
### start-services (infrastructure only)
Start only infrastructure services (database, cache) without the Rails app.
```bash
docker compose up -d postgres
```
Wait for readiness:
```bash
for i in $(seq 1 30); do
docker compose exec -T postgres pg_isready -U postgres > /dev/null 2>&1 && echo "PostgreSQL ready" && break
sleep 1
done
```
### start-app (Rails app only, assumes services are running)
```bash
bin/dev
```
Run in background. Verify:
```bash
for i in $(seq 1 60); do
curl -sf http://localhost:3000/up > /dev/null 2>&1 && echo "Rails ready" && break
sleep 1
done
```
### stop
Stop all local services.
```bash
# Stop Rails processes (bin/dev uses foreman which spawns child processes)
lsof -ti :3000 | xargs kill -9 2>/dev/null || echo "No Rails process on :3000"
# Stop Docker Compose services
docker compose down
```
### restart
1. Run **stop** (above).
2. Wait 2 seconds: `sleep 2`
3. Run **start** (above).
4. Verify all services respond.
### status
Check what is currently running and responsive.
```bash
echo "=== Port Check ==="
echo -n "Rails :3000 — "; lsof -i :3000 2>/dev/null | grep LISTEN > /dev/null && echo "LISTENING" || echo "NOT LISTENING"
echo -n "Postgres :5432 — "; lsof -i :5432 2>/dev/null | grep LISTEN > /dev/null && echo "LISTENING" || echo "NOT LISTENING"
echo ""
echo "=== Health Check ==="
echo -n "Rails /up — "; curl -sf -o /dev/null -w "HTTP %{http_code} in %{time_total}s" http://localhost:3000/up 2>/dev/null || echo "UNREACHABLE"
echo ""
echo "=== Docker Compose ==="
docker compose ps 2>/dev/null || echo "No Docker Compose services running"
echo ""
echo "=== Solid Queue Worker ==="
bin/rails runner "puts SolidQueue::Process.where('last_heartbeat_at > ?', 5.minutes.ago).count.to_s + ' active workers'" 2>/dev/null || echo "Cannot query Solid Queue (app may not be running)"
```
Report results as a table:
| Service | Port | Listening | Responsive |
|---------|------|-----------|------------|
| Rails (web) | 3000 | YES/NO | YES/NO |
| PostgreSQL | 5432 | YES/NO | N/A |
| Solid Queue worker | N/A | N/A | YES/NO (heartbeat) |
---
> Source: [CodySwannGT/lisa](https://github.com/CodySwannGT/lisa) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-22 -->
Sections and files
Listed in source order.
sections -> Prerequisites (run before any operation) → Discovery → Operations → start (full stack) → start-services (infrastructure only) → start-app (Rails app only, assumes services are running)
terms -> Argument · Start infrastructure services · Wait for PostgreSQL · Create and migrate databases · Start the full stack · Wait for Rails · stop · start
files/cmd -> $ARGUMENTS · start · stop · restart · status · start-app · start-services · docker-compose.yml
body sha256 -> 93e33204e26a
Prerequisites (run before any operation)
Verify Docker is running: Check port availability: Verify Ruby and Bundler are available:
Discovery
Read the project's
docker-compose.yml(orcompose.yaml) to identify available services. Common services include:weborapp— the Rails applicationpostgresordb— PostgreSQL databaseworker— Solid Queue background workercss— Tailwind CSS watch processstart (full stack)
Start all Docker Compose services and the Rails application. Start infrastructure services (PostgreSQL, etc.): Wait for PostgreSQL (up to 30 seconds): Create and migrate databases (if needed): Start the full stack via
bin/dev(Procfile.dev) or Docker Compose:start-services (infrastructure only)
Start only infrastructure services (database, cache) without the Rails app. Wait for readiness:
start-app (Rails app only, assumes services are running)
Run in background. Verify: