Commands

Every command works from anywhere inside a project: dqx walks up to find .dq/config.yml, and the directory you are standing in picks the site.

dqx <command> --help prints the flags for any of them.

Every command

dqx has 76 commands. dqx <command> --help prints the flags for any of them.

command	what it does
dqx adopt	Bring any project - v1, v2, v3, or no config at all - into the v4 shape
dqx agent-env	A running copy of this project for an agent to work in, on its own URLs
dqx ai	Show what a coding agent needs from dqx, and write it with --write
dqx artisan	Run php artisan in a site
dqx auth	Report, import or set the credentials the install pipeline needs
dqx bitbucket-ssh	Move Git over SSH to ssh.bitbucket.org: this machine and every known project
dqx build	Build a dev-server site with its proxyBuild, served while its dev server is down
dqx changes	Record a change for the next release, or list what is pending
dqx clean	Stop this project and delete the data the backend can recreate
dqx clone	Copy this project so the copy runs beside it, on its own URLs
dqx composer	Run composer in a site
dqx config	Read the project configuration
dqx configure	Change this project's settings from a patch document
dqx daemon	The sites' long-running processes: list, start, stop, switch on or off for yourself
dqx dashboard	Every project on this machine, in a browser
dqx db	Open this project's database in your client, or print the connection URL
dqx db:export	Export the database
dqx db:import	Import a database dump
dqx desktop	The dashboard as a Mac app
dqx dev	Run the dev server a proxied site needs (proxyCommand in .dq/config.yml)
dqx docs	Open the documentation in your browser
dqx doctor	Report what is and is not working here
dqx domains	Show this project's domains, and what they become under another TLD
dqx down	Stop the environment
dqx e2e	Run this project's browser suite, in the stack, against its own database
dqx exec	Run a command in a site
dqx generate	Print the backend config this project would get
dqx githooks	Write, refresh or remove the git hooks of each site and package
dqx healthchecks	Find compose healthchecks that can never pass, and fix them
dqx image	What the dqx-php images contain, and moving sites between them
dqx images	Find data-owning services on a floating image tag, and pin them
dqx inbox	Open the mail this project sent
dqx info	Every URL, port and connection this project has - or every running project
dqx init	Set up a new project: .dq/config.yml v4, docker-compose.yml and docker confs
dqx install	Set the project up from nothing
dqx kill	Stop every backend and container on this machine, the router included, and free ports 80 and 443
dqx layout	Where the code sits: single (the app repository is the project) or multi
dqx link	Register this project with the backend, without installing it
dqx list	Every project registered here, grouped by project
dqx logs	Tail logs
dqx loopback	Move dqx to another loopback address, so Herd or Valet can keep 127.0.0.1
dqx mcp	Serve dqx over the Model Context Protocol, for coding agents
dqx memory	What each project is using, and what the VM holds beyond that
dqx migrate	Rewrite .dq/config.yml in the v4 shape, after showing what changes
dqx npm	Run npm in a site
dqx open	Open a site in the browser
dqx packages	The packages developed inside this project
dqx php	Run php in a site
dqx prune	Report what on this machine belongs to nothing, and remove it when you say so
dqx redis	Open redis
dqx release	Roll the pending changes into a version, a changelog entry and package.json
dqx remember	Remember a project directory so dqx lists it, without changing anything in it
dqx repair	Check the whole installation, and fix what dqx can
dqx resolver	How local domains resolve on this machine
dqx restore	Put a snapshot back, after taking one of what it overwrites
dqx review	Have Claude review a pull request, and post the findings you pick
dqx router:down	Stop the shared reverse proxy and give 80/443 back
dqx router:status	Whether the router runs, and who holds 80/443 if it does not
dqx router:up	Start the shared reverse proxy, so every project serves at once on 80/443
dqx run	Run a command this project declares in commands:
dqx scan	Read what each site needs: packages, and the node version its image ships
dqx self-update	Update this binary, or say how it should be updated
dqx shell	Open a shell in a site
dqx sites	List the project's sites
dqx snapshot	Save the database and storage this project holds
dqx suffix	The domain suffixes dqx serves here, and the default for new projects
dqx switch	Move this project to another backend, database and URLs included
dqx sync	Write the backend config for this project from .dq/config.yml
dqx test	Run php artisan test in a site
dqx tune	Size this project's database, PHP and search node for a laptop
dqx up	Start the environment
dqx update	Pull the container images this project uses
dqx update-images	Refresh the house container images this machine already has
dqx verify	Request every domain this project declares, and say what answered
dqx version	Print the version, or check it against a minimum
dqx xdebug	Toggle Xdebug for yourself - off by default, never committed

Generated

This table is read from the CLI itself on every docs build, so it lists what actually ships. The sections below cover the ones worth more than a line.

Naming a site

A project serving several sites takes --site <domain> on every command that runs somewhere:

dqx shell --site api.my-app.dqx
dqx artisan --site api.my-app.dqx migrate
dqx exec --site api.my-app.dqx -- composer why laravel/framework

Without it, the site is the one whose directory you are standing in. dqx shell also accepts the domain as a plain argument, which it took before the flag existed. dqx exec --here insists on that: see exec.

In a git worktree inside a checkout, commands run in the worktree, and dqx artisan and dqx test at the worktree's root. A worktree beside the checkout is refused rather than run as the project's only site.

Running a project

up

Start every site of the project. Brings up the shared proxy if it is not running, reissues the certificate when it does not cover a domain yet, and frees a port another project is holding - naming what it stopped.

down

Stop this project.

kill

Stop every project on every backend and free ports 80 and 443. Needs no project - the reason to run it is almost never the project you are standing in, it is that another backend is holding the ports.

The runtimes themselves keep running unless you say otherwise:

dqx kill	every container on the machine, the router included, on every backend; ports freed
dqx kill --all	that, and the runtimes (Docker Desktop, OrbStack, lerd), giving their memory back
dqx kill --mine	leave containers that belong to no project of ours - the safer choice

Whatever it stops, it says what the next dqx up brings back: the router, and under --all the engine.

dqx kill --dry-run lists what it would stop and stops nothing - worth it before the one command that takes away work somebody else may be doing.

dqx down is the project-scoped one.

update

Pull the images this project declares, rather than a hardcoded list.

clean

Remove the environment and the data directories a bind-mounted database leaves behind, which down does not touch. Asks first. The project's route, certificate and profiles stay, because a cleaned project is one you start again; dqx remember --off removes those.

Working inside a project

shell

A shell in the site, in the directory you are standing in. Aliased as bash.

exec

dqx exec -- <command> - one command in the site, in the directory you are standing in.

dqx exec --here -- <command> runs in the site whose checkout you are standing in and nowhere else: no --site, and no falling back to a project's only site. Outside every site's checkout it refuses. The git hooks dqx writes use it from a worktree outside the checkout they were written for: in a dqx clone --worktree copy that is the copy's own site, and anywhere else the refusal keeps Pint off the original's files. See git hooks in worktrees.

php · artisan · composer · npm · test

The tool, in the right container and directory, with the project's credentials available.

run

dqx run <name> - a command the project declared under commands: in its config.

open

The site, in your browser.

review

dqx review [pr] - Claude reviews the changed lines of a pull request on Bitbucket or GitHub, and you pick which findings are posted as comments. In a project with several repositories it lists all of them; dqx review crm#45 names one directly. --branch reviews a branch without posting. --model, --effort and --profile choose for this run: --profile takes a built-in (quick, thorough, security, in any repository), one from review.profiles, or none for the plain review; --language and --code-language set the languages; --post and --json are for scripts. --map prints the pull request's flows and layers as a tree, mapping them with Claude first when the head has no map yet: see mapping the flows. See reviewing a pull request.

logs

dqx logs [service] - tail logs.

xdebug

dqx xdebug on|off, per developer and gitignored. dqx up re-applies your choice.

The database

db

Open a client. dqx db --url prints the URL for a GUI tool. The port is this project's own and stays put, so a saved connection keeps working; this is where the number comes from.

db:import · db:export

dqx db:import <file>, dqx db:export [file].

snapshot · restore

The database and the storage directories, which is what a project needs to actually be restorable. Snapshots live in .dq/snapshots/, which is gitignored: dqx writes the line into a new project's .gitignore, dqx sync adds it to an existing one, and the directory carries a .gitignore of its own, because a dump may hold client data.

dqx restore [name] first takes a before-restore snapshot of what it is about to overwrite, so restoring the wrong one can be undone. --no-safety skips it; an empty one (the database was not reachable) stops the restore before anything changes.

A new snapshot keeps the newest three of yours and, counted apart, the newest three safety snapshots dqx took itself (before-restore, before-clean, before-<backend> from a switch), and removes anything older than 60 days. A run of automatic snapshots never pushes out one you took. A snapshot with a label (dqx snapshot before-import) is a restore point you named: it is never counted out, only removed after 60 days, so a second task on the same project cannot delete it. The snapshot restore takes first removes nothing at all, so it cannot delete the one being restored.

Seeing what is going on

info

Every URL, port and connection this project has. --json for a script or an agent.

list

Every project on the machine, on every backend, one row per checkout with all of its domains. --json supported.

desktop

dqx desktop install builds the dashboard as a Mac app on this Mac and installs it in ~/Applications, with the fleet in the menubar. Apple silicon only. See the Mac app.

doctor

What is broken here, with a severity and a remedy for each finding. --json supported. --all checks the machine, including whether dqx review can reach Bitbucket (the token and its expiry) and GitHub (the gh login); both are warnings at most.

verify

Ask every declared domain what it actually answers. --json supported.

sites

The domains this project serves.

memory

What each project is costing, and what the VM holds beyond that.

scan

What the project's own files say about it - declared versus detected versions, and what disagrees.

Setting a project up

init

Create a project. Flags for the simple case, --from <file> for the whole surface, --scaffold to create the application too. See creating projects.

remember

dqx remember [path] puts a project on the dashboard without changing a file in it. --off forgets it again and removes what dqx keeps for it outside the directory - its routes, its certificate and key, its TLS entry, its profiles and its line in domains.json - printing each path. The directory itself is left alone. See when a project goes.

adopt

Read a project that already exists and write the declaration for it. Prints what it would write and changes nothing; --write applies it.

install

Set the project up from nothing: clone, generate, start, install, run the project's own steps. --only <steps> re-runs one part.

sync

Regenerate the environment from the declaration, keeping anything hand-edited. Reports what it would remove and what disagrees; it never rewrites the declaration itself.

It also tops up an existing .gitignore with what may hold client data and is not there yet: .dq/snapshots/ and .playwright-mcp/, where a coding agent's Playwright MCP server keeps its screenshots of local pages. A new project's .gitignore has both from the start.

switch

Change backend. Refuses, with the reason, when the project needs something the target cannot give.

layout

dqx layout [single|multi] - where the code sits. --dry-run first; see layouts.

loopback

dqx loopback 127.0.0.2 moves dqx's router to another loopback address, so Herd or Valet keep 127.0.0.1. It refuses, changing nothing, while a suffix dqx serves has no working /etc/resolver/<suffix> file or dqx's resolver is not answering, and names the fix per suffix. --force moves anyway with the same warning, --dry-run shows what would happen, refusal included. After the move it checks each suffix answers the new address and suggests sudo killall -HUP mDNSResponder when one does not. dqx loopback shows the state, per suffix too; dqx loopback reset goes back to 127.0.0.1 and is never refused. See Herd and Valet.

link · repair · migrate · domains

Register with the backend, repair a backend's own state, migrate an older config, and rename domains across a project's files.

The tool itself

docs

dqx docs [topic] - this documentation, served locally. dqx docs ssl jumps to the page.

mcp

Run the MCP server for an AI agent. See AI tooling.

config

dqx config get <key> reads the project's configuration; dqx config machine reads and writes this machine's settings.

auth

Report, import or set the credentials composer needs. Composer credentials are discovered, never stored by dqx. The one exception is the Bitbucket token dqx review uses: dqx auth --set bitbucket sets it up and keeps it in the Keychain, --forget bitbucket removes it. See a Bitbucket token.

version · self-update

What this is, and replacing it with the current release.

changes · release

Record a change for the next release, and roll the pending changes into a version.