## Description
Adds `ods stack ls` to list every Onyx dev stack on the machine from any
directory, and lets `stop`/`down --project NAME` act on a stack whose
worktree is gone. The PR also releases port leases when a stack stops
owning them.
**`ods stack ls [--json] [--all] [--orphaned]`**
(`internal/devstack/inventory.go`, `cmd/stack_ls.go`)
- It merges four sources, keyed by Compose project: `docker ps -a` +
`docker inspect` (labels, state, health), `projects/*/owner.json`, every
reachable `state.json` (owner state dirs, plus
`<git-common-dir>/{ods-stack,ods-stack-shared,ods-stack-frontend,worktrees/*/ods-stack,worktrees/*/ods-stack-frontend}`
from owner, lease, Docker and state roots), and `Registry.Leases()`. It
does not call `devstack.Open`, and it takes no locks.
- An Onyx Compose project is one with `relational_db` + `cache`
services, or one that a state or owner record claims.
- Statuses: `active` (an app process is alive, checked with
`groupIsOurs`, so a reused PID does not count), `app-stopped` (infra
runs, phase `stopped`), `infra-only` (infra runs, no app process: a
Compose-only project or dead processes), `stopped`, `orphaned`, and
`stale-lease` (`--all` only).
- Orphan rules: the Compose working dir is gone and no state claims the
project; a state's root is gone; or the root exists but is no longer a
git worktree (state rows, or Docker rows with an owner record whose
state is gone). A row counts as orphaned only when something is left to
clean up: processes, containers, leases or an owner record.
- A missing or corrupt state degrades its row (`errors`). When Docker is
down, `ls` prints a warning and shows rows from saved state only. Exit
codes: 0; 3 when `--orphaned` finds an orphan; 1 when no source can be
read.
**`down`/`stop --project NAME` and `prune`**
(`internal/devstack/project_down.go`)
- The command resolves the stack through `owner.json` → `state_dir`,
then any state that claims the project, then Docker labels. It runs from
any directory.
- It takes the state lock (only if the state dir still exists, so git
metadata is never recreated) and the project lock. It stops recorded
groups with `stopServices`/`stopRecords` and runs `docker compose -p
NAME down` from a neutral dir. Volumes are kept.
- After a successful down it releases the stack's leases and removes
`owner.json` for an orphan.
- It refuses a stack with a live service under an existing git worktree
unless you pass `--force`. If `--project` already matches the current
checkout's stack, the existing checkout path runs.
- `ods stack prune` runs this for every orphaned row after a
confirmation (`--yes` skips it). `--volumes` has its own confirmation,
and `--yes` does not skip it.
**Port lease fixes** (`ports.go`, `lifecycle.go`, `legacy.go`)
- `Stack.Stop` releases app leases (everything except `*_HOST_PORT`).
`Stack.Down` releases app leases after `stopServices`, and every lease
after Compose down. New `Registry.ReleaseNames`.
- Shared adoption (`releaseLegacyLeases`, runs after the legacy guard
and before `leasePorts`): each stopped legacy candidate without live
process groups loses all its leases, or only its app leases while its
containers run.
- Reclaim: `Lease.StateDir` is now recorded (`LeaseFor`). Another
owner's lease is reclaimable when its state is `stopped` or missing,
none of its recorded groups is alive, and, for `*_HOST_PORT` only, its
Compose project has no running container. That last check is lazy, so
app-port leasing stays fast. Leases without `StateDir` are reclaimable
only for shared/frontend keys, which are their own state dirs.
- Drift down: `choosePort` moves a lease to the lowest free port from
`Preferred` when the service is not running. I added
`PortRequest.Running` because `Fixed` alone is not set for a running
service that does not hold its port yet, and moving such a service
changed `web dev`'s full-stack owner
(`TestWebRuntimeUsesTheFullStackWebOwner` caught this).
Docs: `ods stack` help, `tools/ods/README.md`,
`tools/ods/integration/README.md`, and the onyx-dev-stack skill (a new
"Find and stop old stacks" step, and the updated port bullet).
Known limit: `git worktree remove` deletes
`<common>/worktrees/<name>/ods-stack`, so the recorded PIDs are lost.
`down --project` still removes the containers, leases and owner record,
but it cannot find app processes that outlived that removal.
**Discovery-first CLI.** Bare `ods stack` prints a short intro, then
groups its subcommands with the same `AddGroup` pattern as the root
command: Find stacks (`status`, `ls`, `logs`, `plan`), Run this
worktree's stack (`up`, `start`, `restart`, `stop`, `down`), and Clean
up (`prune`). Each `ls` row carries `next`, the exact command that stops
it, and the text output logs it with `log.Info`. Empty results and
refusals name the command to run.
Example on the VM (an isolated stack, then its worktree deleted with `rm
-rf`):
```
$ ods stack ls
PROJECT STATUS APP INFRA WEB AGE ROOT
demo-wt-fd863404 app-stopped - 7/7 - 1m ~/demo-wt
$ rm -rf ~/demo-wt && ods stack ls --orphaned # exit 3
PROJECT STATUS APP INFRA WEB AGE ROOT
demo-wt-fd863404 orphaned - 7/7 - 1m ~/demo-wt (missing)
level=info msg="To stop demo-wt-fd863404 (orphaned), run: ods stack down --project demo-wt-fd863404"
```
After `stack stop`, only the `*_HOST_PORT` leases remained. After `down
--project`, no containers or leases were left.
## How Has This Been Tested?
- Unit tests for the inventory merge (fake containers, owners, states,
leases, liveness): live, app-stopped, infra-only, Compose-only, orphan
with a missing root, a removed worktree whose directory remains, a stale
lease, Docker unavailable, unreadable sources, and sort order.
- Real-process tests for `DownProject`/`StopProject`: an orphan in a
deleted linked worktree is stopped, its leases are released and its
owner record is removed; a live worktree is refused without `--force`.
- Lease tests: reclaim of a stopped owner, live process group skipped,
non-stopped owner skipped, `*_HOST_PORT` with and without running
containers, drift down vs. running, `ReleaseNames`, stop/down releases,
adoption with and without a live legacy group, and the frontend handoff
releasing preview leases.
- Coverage gates: `cmd` is at 90.6% against a 90.4% floor, and
`internal/docker` at 99.3% against 99.2%.
- `go test ./internal/... ./cmd/` passes, except `TestRunCI_failures`,
which also fails on a clean main in this environment. golangci-lint
passes.
- New integration test `TestStackLiveOrphanedWorktree` (`-tags
integration`) passed on the VM (246 s). It starts an isolated stack in a
disposable worktree, deletes the worktree, asserts that `ls --orphaned`
lists the stack with exit 3, then that `down --project` stops its
processes, removes its containers and releases its leases.
## Additional Options
- [ ] [Optional] Please cherry-pick this PR to the latest release
version.
<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit
* **New Features**
* Added `ods stack ls` to view active, stopped, orphaned, and
stale-lease stacks with service, health, port, age, and location
details.
* Added JSON output, filtering, orphan detection, and project-based
shutdown support.
* Added `ods stack prune` to safely clean up orphaned stacks, with
optional volume removal.
* **Bug Fixes**
* Improved port lease reclamation and reassignment for stopped stacks.
* `stop` now releases application ports while preserving infrastructure
ports; `down` releases all ports.
* **Documentation**
* Expanded lifecycle, recovery, listing, and cleanup guidance.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->
---------
Co-authored-by: roshan <rohod04@gmail.com>
Co-authored-by: roshan <38771624+rohoswagger@users.noreply.github.com>
Validate the development stack
Run these tests on a development host with Docker, uv, Bun, and Go installed. Use two disposable Onyx worktrees. Do not use deployments with important data or external credentials. The tests create local accounts, stop services, change ports, and recreate containers.
Build ODS from the branch under test:
ODS_STACK_BUILD_DIR="$(mktemp -d "$(git rev-parse --path-format=absolute --git-path ods-stack-validation).XXXXXX")"
export ODS_STACK_LIVE_BINARY="$ODS_STACK_BUILD_DIR/ods"
go -C tools/ods build -o "$ODS_STACK_LIVE_BINARY" .
Set both worktree paths and run the live lifecycle test:
export ODS_STACK_LIVE_ROOT_A=/absolute/path/to/worktree-a
export ODS_STACK_LIVE_ROOT_B=/absolute/path/to/worktree-b
cd "$(git rev-parse --show-toplevel)/tools/ods"
go test -tags integration ./integration -run TestStackLiveLifecycle -count=1 -timeout 90m -v
The harness explicitly uses the global --isolated option. The test checks distinct projects and ports, database isolation, concurrent startup, process reuse,
stop and start, occupied-port recovery, and data preservation after container recreation.
Unset configuration skips the test, so the normal unit suite does not start Docker.
The test runs stack down during cleanup. Docker volumes and durable port leases remain.
Set ODS_STACK_KEEP_RUNNING=1 to leave the stacks available for browser tests.
Get the current frontend URL with "$ODS_STACK_LIVE_BINARY" --isolated stack status --json in each worktree.
Never assume port 3000 after the occupied-port test.
Run browser tests only after the lifecycle test finishes.
Follow the browser test instructions to start the mock LLM server and install Playwright's browsers.
Set BASE_URL to the disposable stack's frontend URL.
Set MOCK_LLM_SERVER_URL and MOCK_LLM_BACKEND_URL to the test server's reachable address.
cd "$(git rev-parse --show-toplevel)/web"
bun run playwright --config playwright.stack.config.ts
This configuration runs login, signup, welcome-page, and chat-persistence checks without paid-license setup.
Its setup creates the test admin and sets the display name.
When MOCK_LLM_SERVER_URL is set, setup also makes the scripted mock LLM the default provider.
Use the mock provider for an enabled chat input and the real backend chat-persistence check.
Do not run two browser commands with this configuration concurrently; they share an output directory.
Validate orphaned stack discovery and cleanup with one disposable worktree:
cd "$(git rev-parse --show-toplevel)/tools/ods"
go test -tags integration ./integration -run TestStackLiveOrphanedWorktree -count=1 -timeout 45m -v
The test needs ODS_STACK_LIVE_BINARY and ODS_STACK_LIVE_ROOT_A. It adds a temporary
worktree of ODS_STACK_LIVE_ROOT_A, starts an isolated minimal stack there, and deletes the
worktree directory. Then it checks that stack ls --orphaned lists the stack, and that
stack down --project stops its processes and containers and releases its port leases.
After browser tests, validate real Celery processing with the default profile:
cd "$(git rev-parse --show-toplevel)/tools/ods"
ODS_STACK_LIVE_WORKERS=1 go test -tags integration ./integration -run TestStackLiveUserFileWorker -count=1 -timeout 30m -v
Keep the three ODS_STACK_LIVE_* path variables from the lifecycle test.
The worker test uploads a small text file and waits for indexed chunks without mocked status responses.
The first embedding request can download model weights and take several minutes.
Cleanup requests file deletion. The test does not assert that asynchronous deletion finishes.
After browser tests, run "$ODS_STACK_LIVE_BINARY" --isolated stack down in both worktrees.
Stop only the mock LLM server that you started for this run.
Do not prune shared Docker volumes or stop other worktrees.